Day10 多态 final

1 多态

1.1 什么是多态：

父类引用指向子类对象

package com.zhiyou100.Day10;
public class DemoDuoTai01 {
	public static void main(String[] args) {
		Fu f1 = new Fu();//正宗的父类对象
		Zi z1 = new Zi();//正宗的子类对象
		//子类继承父类；子类对象拥有父类中定义的所有成员
		//父类对象可以做的事情  子类对象都能做
		//1:把子类对象 伪装成父类类型————多态
		//		父类引用指向子类对象
		//		给子类对象起个父类类型的名字
		//多态格式：父类引用=子类对象;
		Fu fuzi = new Zi();
	}
	public static void test(Fu fu) {
	}
}
class Fu {
}
class Zi {
}

1.2 多态对象的特点：

除了重写的方法 其他和父类对象完全相同

多态对象：伪装成父类类型的子类对象

• 特点1：多态对象隐藏子类特有成员变量
• 特点2：多态对象隐藏子类特有成员方法
• 特点3：被重新定义的成员变量 显示的父类中定义???
• 特点4：多态的对象 重写的方法 调用的是子类中定义的

package com.zhiyou100.Day10;

import javax.sound.midi.Soundbank;

public class DemoDuoTai01 {
	public static void main(String[] args) {
		Fu f1 = new Fu();//正宗的父类对象
		System.out.println(f1.a);
		f1.hai();
		
		Zi z1 = new Zi();//正宗的子类对象
		System.out.println(z1.a);
		z1.hai();
		//子类继承父类；子类对象拥有父类中定义的所有成员
		//父类对象可以做的事情  子类对象都能做
		//1:-----把子类对象 伪装成父类类型————多态
		//		父类引用指向子类对象
		//		给子类对象起个父类类型的名字
		//多态格式：父类引用=子类对象;
		Fu fuzi = new Zi();
		//多态对象：伪装成父类类型的子类对象
		System.out.println(fuzi);//类型@地址————com.zhiyou100.Day10.Zi@15db9742
		
		System.out.println(fuzi.a);
		//2:-----多态对象有哪些特点：
		//报错：fuzi.b			特点1：多态对象隐藏子类特有成员变量
		//报错：fuzi.game()	特点2：多态对象隐藏子类特有成员方法
		//					  特点3：被重新定义的成员变量 显示的父类中定义：隐藏子类重新定义的成员变量 
		//						   显示从父类继承由于被重新定义而隐藏的成员变量
		fuzi.hao();		    //特点4：多态的对象 重写的方法，调用的是子类中定义的
	}						//总结：多态对象 除了重写的方法 其他和父类对象完全相同
	public static void test(Fu fu) {
	}
}

class Fu {
	int  a=11;
	int  c=22;
	void hai(){
		System.out.println("hai----------fu");
	}
	void hao(){
		System.out.println("hao----------fu");
	}
}

class Zi extends Fu{
	int a=1;
	int b=2;
	
	void hao(){
		
		System.out.println("hao----------zi");
	}
	void game(){
		System.out.println("game----------zi");
	}
}

1.3 多态使用场景1:

定义方法参数列表时 定义为父类类型 这样就可以传递任意子类类型的对象

未使用多态:

1: 代码复用性差：为每一种动物写一个wei方法

2: 代码扩展性差： 如果有新的类型动物：还需要在Demo03DuoTai01为此类型的动物添加一个wei方法

3: 代码耦合度高：Demo03DuoTai01类的开发 必须等待Dog、Pig、Cat类创建完毕 才能写不同的wei方法 否则编译器报错

使用多态来实现:

1 ： 代码复用性强：所有的Animal2都可以使用此wei方法：wei(Animal2 animal2)

2 ： 代码扩展性强： 如果有新的类型动物：只需要此新动物继承Animal2类型即可

3 ： 代码耦合度低：Demo03DuoTai01类的开发和Dog、Pig、Cat类开发 可以完全实现同步开发 互不干涉

狗Dog 猫Cat 猪Pig

package com.zhiyou100.Day10;
public class DemoDog01 {
		//多态使用场景1：定义方法参数列表时  定义为父类类型  这样就可以传递任意子类类型的对象
	public static void main(String[] args) {
		Dog dog=new Dog("d", "hh");
		wei(dog);
		Cat cat=new Cat("c","mm");
		wei(cat);
		Pig pig=new Pig("p", "zz");
		wei(pig);		
		
		/*Dog dog=new Dog("dd", "藏獒");
		wei(dog);	//------------------?
		Cat cat=new Cat("cc", "汤姆");
		wei(cat);
		Pig pig=new Pig("pp", "佩奇");
		wei(pig);*/
	}
    //4 定义喂方法时：参数列表定义为父类类型：：调用方法时 传递任意子类类型的对象
	public static void wei(Animal12 animal12) {
		animal12.eat();
		animal12.yunDong();
	}
/*	private static void wei(Dog d) {//-------------?
		d.eat();
		d.yunDong();
	}
	private static void wei(Cat c) {
		c.eat();
		c.yunDong();
	}
	private static void wei(Pig p) {
		p.eat();
		p.yunDong();
	}
	*/	

}
//2 让所有的子类继承父类
class Dog extends Animal12{
	public Dog(String name, String type) {
		super(name,type);
	}
    //3 根据子类需求 重写eat和yunDong方法
	void eat(){
		System.out.println(type+":"+name+"  正在啃骨头！");
	}
	void yunDong(){
		System.out.println(type+":"+name+"  吃完 捉老鼠！");
	}
}
class Cat extends Animal12{
	public Cat(String name, String type) {
		super(name,type);
	}
	void eat() {
		System.out.println(type+":"+name+"  正在吃鱼！");
	}
	void yunDong() {
		System.out.println(type+":"+name+"  吃完 晒太阳！");
	}
}
class Pig extends Animal12{
	public Pig(String name, String type) {
		super(name,type);
	}
	void eat() {
		System.out.println(type+":"+name+"  正在吃饲料！");
	}
	void yunDong() {
		System.out.println(type+":"+name+"  吃完拱白菜！");
	}
}
//1 提取子类共同成员 形成父类-------------------------
class Animal12{
	String name;
	String type;
	public Animal12(String name, String type) {
		this.name = name;
		this.type = type;
	}//Animal12信息不完整  无法实现eat和yunDong   此方法存在的意义：：为子类定义规范
	void eat(){}
	void yunDong(){}
}

1.4 多态使用场景2:

在定义类的成员变量时 都定义为父类类型 这样就可以赋值任意子类类型的对象

package com.zhiyou100.Day10;

public class DemoLamp {
	//创建灯泡对象
	RedBulb rdBulb=new RedBulb("红灯一号");
	GreenBulb  grBulb=new GreenBulb("绿灯一号");
	//创建台灯对象
	Lamp lamp = new Lamp();
	//灯泡和台灯关联
	lamp.redBulb=rdBulb;
	
	lamp.on();
	lamp.off();
	
	lamp.greenBulb=grBulb;
	lamp.on();
	lamp.off();
}

//红灯泡
class RedBulb {
	String name;

	void light() {
		System.out.println(name + "红");
	}

	public RedBulb(String name) {
		this.name = name;
	}
}

//绿灯泡
class GreenBulb {
	String name;

	void light() {
		System.out.println(name + "绿");
	}

	public GreenBulb(String name) {
		this.name = name;
	}
}

class Lamp {
	//定义属性记录当前台灯上的灯泡
	RedBulb redBulb;
	GreenBulb greenBulb;

	public void on() {
		if (redBulb != null) {//引用数据类型的默认初始值是 null
			redBulb.light();
		}
		if (greenBulb != null) {
			greenBulb.light();
		}
	}

	public void off() {
		System.out.println("关灯");
	}
}

2 final

最终的：修饰符：修饰：：类+成员变量+局部变量+普通方法

final修饰的类：不能被继承
final修饰的方法：不能被重写

final修饰的成员变量 没有默认初始值
final修饰的变量 只能赋值一次
final修饰的变量---常量(final修饰的变量+常量值)
final常量 命名规范：所有字母大写+单词之间用_分割：final S_D_METHOD

public class Demo01Final {
    public static void main(String[] args) {
    	Demo011FinalClass  d1=new Demo011FinalClass();
	}
}
// final修饰的类 不能被继承
 final class Demo011FinalClass{
	 int a=0;
	 void show() {}
 }
 //class Zi011 extends Demo01FinalClass{}
 //The type Zi011 cannot subclass the final class Demo01FinalClass
 
 //final修饰的成员变量 没有默认初始值
 //final修饰的变量 只能赋值一次
 //final修饰的变量---常量(final修饰的变量+常量值)
 //final常量 命名规范：所有字母大写+单词之间用_分割：final String  WO_DE_SEHN_FEN_ZHONG_ID="410185198602221111";
 class Demo012{
	 int c;
	 final int a;//The blank final field a may not have been initialized
	 Demo012(int a){
		 this.a=a;
	 }
	 void show() {
		 final int b=1;
		 //b++;//The final local variable b cannot be assigned. It must be blank and not using a compound assignment
		 System.out.println(b);
	 }
 }
 
 class Demo013{
	 final void show() {}
	 void hai() {}
 }
 
 //final方法 不能被重写
 class Damo013Zi extends Demo013{
	 //final void show() {}// Cannot override the final method from Demo013
	 void hai() {}
 }