1、final关键字
1、final:不可更改的
2、final可以修饰类【不能被继承】,成员变量【变量变常量】,成员方法【方法不能被重写】
3、常量定义的格式:public static final double PI = 3.141592653589793;
多态
多态就是事物的多种形态
对象的多态性:同一个对象,可能具有不同的名称,可以有不同类型的引用指向它【同一个对象,有不同的名称和描述】
类的多态性:同一个类型,可能有不同子类的实现。同一个类型的引用,可能会指向不同子类的对象。【同一个名字和描述,可能在不同场景有不同的实现】
多态的前提:要有继承关系,有方法的重写,父类引用指向子类对象
2、多态中成员变量的访问特点
1、编译看左边,运行看左边
编译看左边:如果左侧父类中没有定于相关的变量,就会编译不通过
运行看左边:如果左侧父类中有对应的成员变量,就会执行父类中的成员变量
多态多种成员方法的访问特点
编译看左边,运行看右边
编译看左边:如果左侧父类中没有定义相关的方法,就会编译不通过
运行看右边:如果右侧对象所属类型中有相应的成员方法,就会之那个对象所属类型的方法【非静态】
public static void main(String[] args) {
//父类引用指向子类对象
//成员变量是从一个类的角度去描述一个对象
Animal a = new Cat();
Cat a1 = new Cat();
//编译看左边,运行看左边
System.out.println(a.color);//动物类的color属性
System.out.println(a.age);//30
a.show1();//147
}
class Animal {
String color = "动物类的color属性";
int age = 30;
public void show1() {
System.out.println("123");
}
}
class Cat extends Animal {
String color = "橘色的猫";
int age = 3;
public void show1() {
System.out.println("147");
}
}
## 多态中静态方法的访问特点
1、编译看左边,运行看左边
2、静态的最终解释:
(1)静态变量:存储在类的字节码文件中,被所有对象共享,不随着对象的变化而变化,所有的对象都具有相同的静态变量,所以称之为静态变量
(2)静态方法:只会根据引用所属的父类类型,来决定要运行的内容,和对象没有任何关系,不会随着对象的变化而变化,所以称之为静态方法
(3)多态讨论的是对象的情况,静态与对象无关,所以静态的成员只根据类来讨论,不用考虑多态性,静态也不具备多态性
## 向下转型
1、如果子类对象想要执行自己所属类型特有的方法,就要从父类引用指向子类对象编程本类引用指向本类对象
2、格式:(目标类型)要转换的对象:IronMan im = (IronMan)m;
3、本质:恢复了子类对象原本具有的访问范围
## 向上转型
1、原本使用子类对象引用指向子类的对象,变化成了父类引用指向子类对象。本质:缩小了访问范围,减少了访问权限
```java
public static void main(String[] args) {
Man m = new IronMan();
System.out.println(m.name);//托尼史塔克
m.dealBusiness();//谈几个亿的大生意
//向下转型
IronMan im = (IronMan)m;
im.fly();//飞
im.dealBusiness();//谈几个亿的大生意
//向上转型
IronMan im1 = new IronMan();
Man m2 = im1;
m2.dealBusiness();//谈几个亿的大生意
System.out.println(m2.name);//托尼史塔克
}
class Man {
String name = "托尼史塔克";
public void dealBusiness() {
System.out.println("谈生意");
}
}
class IronMan extends Man {
String name = "钢铁侠";
public void dealBusiness() {
System.out.println("谈几个亿的大生意");
}
public void fly() {
System.out.println("飞");
}
}
总结:当子类重写了父类的成员方法,父类成员变量访问父类成员方法就变成重写之后子类的成员方法;当向上转型之后访问的成员方法依然是重写的成员方法
多态的好处
1、提高了代码的可扩展性
2、在方法的参数列表中定义父类的引用,将来传入子类的对象都可以使用
3、在实际开发中,对象的来源非常广泛,例如:自己new的,调用方法返回的,文件中读取的,框架底层利用反射机制自动创建的,从网络中传输的等等,如果使用之前本类引用指向本类对象,接受对应的对象难度较大,可以结合多态,保证接收的遍历。
public static void main(String[] args) {
JuiceMachine jm = new JuiceMachine();
Apple a = new Apple();
Pear p = new Pear();
Melon m = new Melon();
Fruit f = new Melon();
a.flow();//流出苹果汁
p.flow();//流出冰糖雪梨汁
m.flow();//流出西瓜汁
f.flow();//流出西瓜汁
}
class JuiceMachine {
public void makeJuice(Fruit f) {//Fruit f = new Apple();
f.flow();
}
public void makeJuice(Apple a) {
a.flow();
}
public void makeJuice(Pear p) {
p.flow();
}
public void makeJuice(Melon m) {
m.flow();
}
}
class Fruit {
public void flow() {
System.out.println("流出水果汁");
}
}
class Apple extends Fruit {
public void flow() {
System.out.println("流出苹果汁");
}
}
class Pear extends Fruit {
public void flow() {
System.out.println("流出冰糖雪梨汁");
}
}
class Melon extends Fruit {
public void flow() {
System.out.println("流出西瓜汁");
}
}
class Mango extends Fruit {
@Override
public void flow() {
System.out.println("流出芒果汁");
}
}
instanceof关键字
1、格式:A instanceof B
2、关键字,是一个运算符,【A是一个对象,B是一个类型。用于判断A对象是否和B类型有关,如果A对象和B类型有关就返回true,否则返回false】
抽象
1、抽象:抽取相似的、相同的代码部分
2、抽象方法:只有方法声明,没有方法实现的方法,就是抽象方法,额外的在方法声明上加上abstract关键字,用来表明是一个抽象方法
3、定义格式:抽象方法只有方法声明没有方法实现,连大括号都没有,直接在参数列表之后加上分号,在方法的声明上额外添加abstract关键字即可
抽象类
1、可以定义抽象方法的类就是抽象类
2、格式:
abstract class 类名 {}
public class Duixiang {
public static void main(String[] args) {
Animal a = new Dog();
a.call();
}
}
abstract class Animal {
public abstract void call();//抽象方法
}
class Cat extends Animal {
@Override
public void call() {
System.out.println("喵喵喵");
}
}
class Dog extends Animal {
@Override
public void call() {
System.out.println("汪汪汪");
}
}
抽象类特点
1、抽象类和抽象方法都必须用abstract
抽象类:abstract class 类名{ }
抽象方法:public abstract void 方法名(列表);
2、抽象类和抽象方法的区别:
抽象方法所在的类必须是抽象方法
抽象类中不一定都是抽象方法
3、抽象类不能实例化(不能创建对象)
抽象类成员的特点
1、可以有成员变量,用于给子类继承【子类是非抽象类】
2、有构造方法,用于给成员变量赋值
3、有成员方法,可以是抽象方法也可以是非抽象方法【非抽象方法可以直接被子类继承,抽象方法需要子类重写】