# 面向对象 * * * ## 问题 ~~~ public class DianWorker{ String name; String sex; public void work(){ System.out.println(name+"工作") } } public class QianWorker{ String name; String sex; public void work(){ System.out.println(name+"工作") } } public class WaWorker{ String name; String sex; public void work(){ System.out.println(name+"工作") } } ~~~ 三个类当中存在着相同的属性和行为，这里写了三次，为了解决这个问题--**继承** * * * ## 继承(泛化)（extends） 概念 一个Java类可以从一个现有的类（父类，基类，超类）当中派生出来，派生出来的类（子类）具有父类的所有属性和方法，除了构造器和私有成员 特点 子类还可以增加自己独有的属性和方法来拓展功能 Java中的继承--单继承（一个类只能有一个直接父类） 继承提高了代码的复用性，也是实现**开闭原则**的基础 ### 开闭原则：对拓展开放，对修改关闭 如何判断继承关系 1.A is a kind of B（A是一种B）-->B就是A的父类 2.里氏替换原则--任何父类可以出现的地方，子类一定可以出现，子类能够完全替代父类的功能 ### 子类实例化过程 实例化子类对象，子类构造器先默认去调用父类的无参构造器先生成父类对象，然后再生成子类对象，如果父类没有无参构造器，子类构造器就必须显示调用父类的其他有参构造器 ### super关键字 代表父类对象，使用与this完全一样 1.super.属性，super.方法名() 2.super()父类构造器 ### 封装 #### 访问权限操作符  **概念** 将属性和方法用不同的访问权限操作符修饰（控制可见范围），放入一个类中的过程 ### 方法重写（override覆盖，rewrite，运行时多态） 一定发生在子类当中，与父类**同名，同参，同返回值类型**的方法，子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限 ### 重写（运行时多态，override）与重载（编译时多态，overload）的区别？ ~~~ //重写:一定发生在子类当中，与父类**同名，同参，同返回值类型**的方法，子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限 //重载:同一个类当中，同名不同参的方法，与返回值类型无关 ~~~ ### 多态（解耦合） 字面意义：一个事物的不同形态（对同一消息做出的不同响应） 编码意义：一个方法的不同实现 设计意义：将做什么和怎么做分开 前提： 1.要有泛华（继承）关系 2.要有方法重写 3.要有上溯造型（父类引用指向子类对象） * * * ### static静态 static能修饰方法，属性。 static修饰的方法（静态方法）和属性（静态属性），可以直接通过类名调用，所以静态属性和静态方法不在堆区当中，而在方法区当中的静态区（共享区） 静态区中的静态属性和静态方法归这个类所有对象共享 静态方法只能直接访问静态成员 **备注** 1.static不能修饰类 2.static不能修饰构造器 3.static不能修饰局部变量 4.static不能修饰抽象方法 ### 静态块：给静态属性初始化 执行时机：类型信息被加载到方法区中时 ~~~ static { System.out.println("静态块被调用"); num = 100; } ~~~ * * * ### 单例模式（保证一个类只有一个实例-->对象） **饿加载** ~~~ public class Singleton{ //饿汉模式--饿加载 private staticSingleton s = new Singleton()； /* * 单例模式： * 保证一个类只有一个实例（对象） */ //构造器私有--不让其他类随意new对象 private Singleton(){ } //返回一个实例的方法--公有，静态的，返回值类型为Singleton的方法 public static Singleton getInstance(){ return s; } } ~~~ **懒加载** ~~~ public class Singleton{ //懒汉模式--懒加载 private static Singleton s; /* * 单例模式： * 保证一个类只有一个实例（对象） */ //构造器私有--不让其他类随意new对象 private Singleton(){ } //返回一个实例的方法--公有，静态的，返回参数类型为Singleton的方法 public static Singleton getInstance(){ if(s == null){ s = new Singleton(); } return s; } } ~~~ * * * ### final关键字 final能修饰类，方法，属性 final修饰类，最后的类不能被继承 final修饰方法，最后的方法，不能被重写 final修饰属性，最后的属性，不能被修改 * * * ### 抽象类（abstract） 抽象方法：没有方法体（块），如果一个类当中存在抽象方法，那么这个类必须是抽象类 **抽象类不能实例化**（但是有构造器），它唯一的作用-->被继承（充当父类） 一旦一个子类继承了一个抽象类，就必须重写父类的所有抽象方法，除非这个子类也是抽象类 **思考：abstract与final能不能同时修饰一个类？** 答：不能，abstract类唯一的作用就是被继承；final类不能被继承，即使能修饰，这个类也毫无意义 * * * ### 接口（interface） 如果一个类当中的所有方法都是抽象方法，这个类可以定义为一个接口--接口不是类 接口只能用**public**和**默认**修饰，**工作不存在，默认接口** 因为Java类是单继承，所以出现了接口，为的是弥补单继承的缺点 **接口中的成员** 1.只允许声明常量 2.只允许声明抽象方法 属性，存在默认前缀**public static final** 方法，存在默认前缀**public abstract** 类与类的关系--单继承 类与接口的关系--多实现 ~~~ public class InterfaceAImp implements InterfaceA{ public void test(){ System.out.println("实现A接口"); } } ~~~ 接口与接口的关系--多继承 ~~~ public interface InterB extends InterA，InterC{ } ~~~ * * * ### 面试题：抽象类和接口有哪些区别？ 1.抽象类和接口都不能实例化 2.抽象类有构造器，接口没有 3.类是单继承，接口是多实现 4.抽象类是抽象成员和非抽象成员的集合体，接口中只允许存在常量和抽象方法 * * * ### 接口的应用 接口就是一套规范  ~~~ public interface News{ //增加一条新闻 void addNews（）； } public class Sport implements News{ public void addNews（）{ System.out.println("发布一条体育新闻到体育模块"); } } ~~~ ~~~ public class Happy implements News{ public void addNews(){ System.out.println("发布一条娱乐新闻到娱乐模块"); } } ~~~ ~~~ public class ZhangZhi implements News{ public void addNews(){ System.out.println("发布一条政治新闻到政治模块"); } } ~~~ ~~~ public class Main{ public static void main(String[] args){ New n = null; while(true){ Scanner scan = new Scanner(System.in); System.out.println("请输入要发布什么新闻："); System.out.println("1-----体育新闻"); System.out.println("2-----娱乐新闻"); System.out.println("3-----政治新闻"); System.out.println("4-----退出程序"); int option = scan。nextInt（）； if（option < 0 || option > 4）{ System.out.println("无效数字"); continue； } switch(option){ case 1: n = new Sports(); break; case 2: n = new Happy(); break; case 3: n = new ZhangZhi(); break; case 4: System.out.println("谢谢！！！"); return; } n.addNews(); } } } ~~~ * * * ### 内部类（innerClass） 内部类的唯一作用：能够直接访问外部类成员，包括私有解决接口中的方法同名同参问题： ~~~ public class InterImpTest implements Interface1{ public void test(){ System.out.println("1"); } public class InnerClass implements Interface2{ public int test(){ System.out.println("2"); return 0; } } } ~~~ * * * ### 总结： **1.面向对象的四大特性** （1.）继承 一个Java类可以从一个现有的类（父类，基类，超类）当中派生出来，派生出来的类（子类）具有父类的所有属性和方法，除了**构造器**和**私有成员**，子类还可以增加自己独有的属性和方法来拓展功能 （2.）封装 将属性和方法用不同的访问权限操作符修饰（控制可见范围），放入一个类中的过程 （3.）多态（解耦合） 对同一消息做出的不同响应 前提： 1.要有泛华（继承）关系 2.要有方法重写 3.要有上溯造型（父类引用指向子类对象） （4.）抽象 将事物的主要特征和行为抽象成概念模型，在Java中抽象类和接口都是抽象的体现 * * * **2.static** static能修饰方法，属性。 static修饰的方法（静态方法）和属性（静态属性），可以直接通过类名调用，所以静态属性和静态方法不在堆区当中，而在方法区当中的静态区（共享区） 静态区中的静态属性和静态方法归这个类所有对象共享 静态方法只能直接访问静态成员 #### 备注 static不能修饰类 static不能修饰构造器 static不能修饰局部变量 static不能修饰抽象方法 * * * **3.单例模式** 懒加载 * * * **4.抽象类和接口** 抽象类和接口都不能实例化 抽象类有构造器，接口没有 类是单继承，接口是多实现 抽象类是抽象成员和非抽象成员的集合体，接口中只允许存在常量和抽象方法 * * * **5.final关键字** final能修饰类，方法，属性 final修饰类，最后的类，不能被继承 final修饰方法，最后的方法，不能被重写 final修饰属性，最后的属性，不能被修改 * * * **6.方法的重写** 一定发生在子类当中，与父类**同名，同参，同返回值类型**的方法，子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限 * * * **7.上溯造型** 父类引用指向子类对象