一.三大特征:
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:本质是什么呢?------------局部内部类
【面向对象】*是一个继承了该类或者实现了该接口的子类匿名对象。
文章图片
推荐阅读
- 面向对象编程|深入理解面向过程与面向对象的思想差异与各自特色
- 面向对象|面向对象 抽象方法、抽象类
- 使用面向对象和功能性方法来重构Java应用
- [ C++ ] 你知道什么是OOP(面向对象编程)，什么是封装（ --类与对象（上））
- #yyds干货盘点# Java 基础 - 面向对象的三大特性
- #私藏项目实操分享#Go 语言入门很简单（Go 如何面向对象）
- 面向对象的设计原则你不要了解一下么（）
- 设计模式铺铺路(面向对象设计的原则一二)
- #指尖人生#面向对象设计常用的设计模式-桥接模式