面向对象

一.三大特征:
1.封装: 把数据封装起来,不让外面随便访问
2,继承: 子类继承父类,有共同点
3.多态: 事物存在的多种形态

public 公共的,所有类都可以访问;
private 私有的,只有本类可以访问
protected 同一包,当前类,子孙类可以访问
default 同一个包内,本类可以访问
不同包调用,要导包

private 私有属性,要set,get方法
this. 当前的实例
3.final
final 加到变量上,就成为常量;不能修改
final 加到方法前,这个方法不能被子类覆盖(不能重写)
final 加到类前,表示这个类不能被继承
二. 继承
1.* A:this和super都代表什么

• this:代表当前对象的引用,谁来调用我,我就代表谁
• super:代表当前对象父类的引用
• B:this和super的使用区别
• a:调用成员变量
  *this.成员变量 调用本类的成员变量,本类没有也可以调用父类的成员变量
• super.成员变量 调用父类的成员变量
• b:调用构造方法
• this(...) 调用本类的构造方法
• super(...) 调用父类的构造方法
• c:调用成员方法
• this.成员方法 调用本类的成员方法,也可以调用父类的方法
• super.成员方法 调用父类的成员方法
  2.重载和重写的区别
• A:方法重写注意事项
• a:父类中私有方法不能被重写
• 因为父类私有方法子类根本就无法继承,既然子类无法继承,就谈不上重写了
• b:子类重写父类方法时，访问权限不能更低
• 最好就一致
• c:父类静态方法，子类也必须通过静态方法进行重写
• 子类重写父类方法的时候，最好声明一模一样。
• Override和Overload的区别?Overload能改变返回值类型吗?
• overload可以改变返回值类型,只看参数列表
• 方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
• 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。
• 子类对象调用方法的时候：
• 先找子类本身，再找父类。
  2.静态优先于非静态,父类优先于子类,构造代码块优先于构造方法
  三.多态
• A:多态(polymorphic[,pɒlɪ'mɔːfɪk])概述
• 事物存在的多种形态
• B:多态前提
• a:要有继承关系。
• b:要有方法重写。
• c:要有父类引用指向子类对象。father f = new son(); ///////向上转型
  1.多态中的成员访问特点之成员变量
  成员变量
  编译看左边(父类),运行看左边(父类)
  成员方法
  编译看左边(父类)，运行看右边(子类)。///////////////动态绑定
  静态方法
  编译看左边(父类)，运行看左边(父类)。
  (静态和类相关，算不上重写，所以，访问还是左边的)
  只有非静态的成员方法,编译看左边,运行看右边
  2.instanceof 判断前面这个对象是否属于后面这个类

if (animal instanceof Dog) {
     System.out.println("这是一条狗");
     Dog d = (Dog)animal;
     d.bite();
}else if (animal instanceof Cat) {
     System.out.println("这是一只猫");
     Cat c = (Cat)animal;
     c.bite();
}

3.static关键字
(1)被static关键字修饰的成员，属于该类中所有对象的共享内容可以直接用类名调用，也可以用对象调用，但是建议用类名调用
(2)随着类的加载而加载,优先于对象存在：随着字节码文件的加载而加载的，那时候还没有对象呢
(3)静态修饰的内容一般我们称其为：与类相关的，类成员（静态变量：类变量，静态方法：类方法）
(4)在静态方法中是没有this关键字的(因为this指的是一个具体的对象,而静态在加载到内存时还没有具体的对象)
(5)静态方法只能访问静态的成员变量和静态的成员方法,非静态的成员方法既可以方法静态的成员方法和成员变量，又能访问非静态的成员方法和成员变量
简单记忆：静态不能访问非静态
4.组合是 has a 的关系,继承是is a的关系(我有一条狗,,,,,,,,,狗继承动物)
优先使用组合,因为他灵活
继承尽量不要超过三层
5.abstract 关键字

• A:抽象类概述
• 抽象就是看不懂的 ,不能被实例化
• B:抽象类特点
• a:抽象类和抽象方法必须用abstract关键字修饰
• abstract class 类名 {}
• public abstract void eat();//当不知道该方法具体是怎么实现的
  //比如动物吃，你知道它吃什么吗？怎么吃？都不知道
• b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
• c:抽象类不能实例化那么，抽象类如何实例化呢?
• 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
• d:抽象类的子类
• 要么是抽象类
• 要么重写抽象类中的所有抽象方法

• A:抽象类的成员特点
• a:成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
• b:构造方法：有。
• 用于子类访问父类数据的初始化。
• c:成员方法：既可以是抽象的，也可以是非抽象的。
• B:抽象类的成员方法特性：
  *a:抽象方法 强制要求子类做的事情。/////子类必须实现
  publicabstractvoidmethod();// 抽象方法只要定义就行,不要具体的实现
• b:非抽象方法 子类继承的事情，提高代码复用性。////子类可以直接使用
  接口的方法都是抽象的
  1.接口
  接口特点
• a:接口用关键字interface表示
• interface 接口名 {}
• b:类实现接口用implements表示
• class 类名 implements 接口名 {}
• c:接口不能实例化
• 那么，接口如何实例化呢?
• 按照多态的方式来实例化。
• d:接口的子类
• a:可以是抽象类。但是意义不大。
• b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
  接口与类相似点：
  一个接口可以有多个方法。
  接口文件保存在.java结尾的文件中，文件名使用接口名。
  接口的字节码文件保存在.class结尾的文件中。
  接口相应的字节码文件必须在与包名称相匹配的目录结构中。
  接口与类的区别：
  接口不能用于实例化对象。
  接口没有构造方法。
  接口中所有的方法必须是抽象方法。
  接口不能包含成员变量，除了static和final变量。
  接口不是被类继承了，而是要被类实现。
  接口支持多重继承。
  *A:接口成员特点
  *成员变量只能是常量，并且是静态的并公共的。
• 默认修饰符：public static final
• 建议：自己手动给出。
• 构造方法：接口没有构造方法。
• 成员方法：只能是抽象方法。//////接口的方法都是抽象的
• 默认修饰符：public abstract
• 建议：自己手动给出。
  3.defualt关键字

default void report() { //加defalut 可以声明方法
System.out.println("汇报相关数据");
}

2.内部类
内部类访问特点

• a:内部类可以直接访问外部类的成员，包括私有。
• b:外部类要访问内部类的成员，必须创建对象。
• 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
  out.int oi - new out().new int();
  oi.方法();
  3.静态成员内部类
• static
• B:成员内部类被静态修饰后的访问方式是:
• 外部类名.内部类名 对象名 = 外部类名.内部类对象;
  Outer.Inneroi=newOuter.Inner();
  //外部类是一个普通类,但是内部类是一个静态类,那么一个普通类访问静态成员时可以用类名.的方式,

4.(成员内部类私有使用)

• private：在外部不能直接创建内部类对象了

5.局部内部类:(外部类里面方法里的类)

3.匿名内部类;

• A:匿名内部类
• 就是内部类的简化写法。
• B:前提：存在一个类或者接口
• 这里的类可以是具体类也可以是抽象类。
• C:格式：

new 类名或者接口名(){
重写方法;
}

• D:本质是什么呢?------------局部内部类
  *是一个继承了该类或者实现了该接口的子类匿名对象。