一.三大特征:

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:本质是什么呢?------------局部内部类

*是一个继承了该类或者实现了该接口的子类匿名对象。