《学习笔记》面向对象（四）多态，instanceof关键字，抽象

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、有成员方法，可以是抽象方法也可以是非抽象方法【非抽象方法可以直接被子类继承，抽象方法需要子类重写】