面向对象
一.三大特征:
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:本质是什么呢?------------局部内部类
*是一个继承了该类或者实现了该接口的子类匿名对象。
