10. java之多态

1.(扩展)成员变量 VS 局部变量:在同一个范围内不能声明同名的变量,在不同范围内可以有同名的变量.

1.1:声明位置不同:成员变量在类中直接声明;局部变量在方法中声明.
1.2:生命周期不同:成员的生命周期随着对象创建而产生,随着对象销毁而结束;局部变量的生命周期仅在声明的方法中.
1.3:作用域不同:成员变量的作用由访问修饰符决定;局部变量的作用在声明它的大括号中.
1.4:默认初值不同:成员变量不赋值有默认值,String类型默认值是null,int类型默认值0,double类型默认值0.0,boolean类型默认值false,char类型默认值是\u0000;局部变量不赋值没有默认值.
1.5:访问修饰符不同:成员变量一定有访问修饰符;局部不能用访问修饰符.
1.6:在内存中位置不同:成员变量声明在内存堆中;局部变量声明在内存的栈中.
1.7:优先级不同:当成员变量和局部变量同名时,局部变量的优先级更高.

2.Object:是所有java类的根类,所有的Java类都直接或间接继承Object类.

	常用方法:
	2.1:toString():返回对象的字符串表示形式。
		注意:如果当前对象所有类中没有重写toString(),只是从Object类继承,当前对象调用toString()输出的是内存地址. 
			如果当前对象所有类中重写了toString(),当前对象调用toString()输出的是重写的内容.

	2.2:hashCode():返回对象的哈希码值。每个对象调用hashCode()时都可以得到唯一一个
		哈希码值,如果两个对象指向同一块内存地址,它们的哈希码值才相同.

	2.3:== vs equals()
		==:==左右两边的变量是基本数据类型,比的是两个变量的值;==左右两边的变量是	引用数据类型,比的是两个变量的内存地址.
		equals():equals()左右两边变量所在类如果没有重写equals(),而是直接从Object继承的,那么equals()的作用比内存地址;equals()左右两边变量所在类重写equals(),那么equals()比较的是两个变量的值.
		注意:String类底层重写Object的equals(),所以String类的变量调用equals()比的是变量的值.
		eg:public static void main(String[] args) {
		//创建对象
		Student stu1=new Student("张三", 80);
		Student stu2=new Student("张三", 80);
		
		int num1=11;
		int num2=11;
		
		//==左右两边是基本数据类型,比值
		System.out.println(num1==num2);//true
		//==左右两边是引用数据类型,比地址
		System.out.println(stu1==stu2);//false
		
		//stu1和stu2两个变量所在类Student类没有重写equals(),而这两个变量是引用数据类型,比地址
		//stu1和stu2两个变量所在类Student类重写equals(),比值
		System.out.println(stu1.equals(stu2));//false//true
	}

3.final:最终的,可以修饰类,方法,变量.

3.1:最终类(断子绝孙类):用final修饰的类叫最终类.最终类不能被继承.
3.2:最终方法:用final修饰的方法叫最终方法.最终方法不能被重写.
3.3:常量:用final修饰的变量叫常量.常量一生只能赋一次值,一但赋值不可更改.
	成员常量:可以在声明的同时赋值,还可以构造方法中给成员常量赋值.
	局部常量:可以在声明局部常量时直接赋值,还可以先声明局部常量,再赋值
	eg:public class Pet {
            public String nickName;
        	public String breed;
        	//成员常量在声明直接赋值
        	public final int age=11;
        	//声明成员常量,用构造方法赋值
           private final int height;
public Pet() {
	//给常量赋值
	height=170;
}


public Pet(String nickName, String breed, int height) {
	super();
	this.nickName = nickName;
	this.breed = breed;
	//给常量赋值
	this.height = height;
}

/**
 * 最终方法不能被重写
 */
public final void bark() {
	//声明局部常量时直接赋值 
	final int num1=11;
	//先声明局部常量,再赋值
	final int num2;
	num2=22;
	
	System.out.println(nickName+"在叫");
}
}

4.多态:也是面向对象的三大特性之一.
4.1:多态概念:
生活中多态:同一种事物在不同条件执行不同的操作.
程序中多态:由同一个父类或父接口作为数据类型,指向不同子类对象,调用相同的方法,执行不同操作叫多态.
4.2:多态应用:
4.2.1:用父类或父接口作为数据类型,创建不同的子类对象,调用子类重写父类的方法而执行不同的操作.

//新建一个宠物类
	public class Pet {
private String cname;  //宠物名

public String getCname() {
    return cname;
}
public void setCname(String cname) {
    this.cname = cname;
}

public void print(){
    System.out.println("打印宠物类的信息:");
}

//有猫
public class Cat extends Pet {
    @Override
    public void print() {
        System.out.println("猫咪的打印信息:");
    }
}

//有狗
public class Dog extends Pet {
    @Override
    public void print() {
        System.out.println("狗狗的描述信息");
    }
}

//新建一个主人类定义两个方法
public class Master {
    private String name;  //主人名

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void feed(Pet pet){ //注意：不要看是谁调的，要看谁传的
        //多态：父类引用对象指向子类对象，可调用子类重写的方法
        String cname = pet.getCname();  //继承性
        System.out.println("主人"+name+"给"+cname+"喂食");
        pet.print();  //主人给宠物喂食..给谁？，调的是子类重写方法--多态性
    }


    public Pet adopt(int num) {  //领养宠物的方法
        if(num==1){
            Dog dog = new Dog();
            return dog;  //返回狗对象
        }else if(num==2){
            Cat cat = new Cat();
            return cat;  //返回猫对象
        }
        return null;
    }
}

//新建一个测试类
public class Test9_9 {
    public static void main(String[] args) {
        //1 使用父类作为方法形参实现多态
        Master master = new Master();  //实例化主人、猫、狗的对象
//		master.setName("张三疯");
//		Cat cat  = new Cat();
//		cat.setCname("大脸猫");
//
//		Dog  dog = new Dog();
//		dog.setCname("招财狗");
//		master.feed(cat);  //主人给猫喂食
//		master.feed(dog);  //主人给狗喂食

        //2 使用父类作为方法返回值实现多态
        System.out.println("请输入你要领养的宠物:1.狗狗，2：猫咪");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        Pet pet = master.adopt(num); //父类对象指向子类对象
        //NullPointerException: 当为null时，调了属性或方法，则会出现空指针异常
        if(pet != null){
            pet.print();  //可调用子类重写方法
        }else{
            System.out.println("没有返回的宠物对象...");
        }

    }
}

5.引用类型数据转换

5.1:向上转型:将子类对象存在父类变量中叫向上转型.向上转型是自动类型转换.
	语法:父类型 变量名=子类对象;
		eg:Pet c1=new Cat();
      	  Pet d1=new Dog();

5.2:向下转型:将父类类型的变量转换为原来子类对象叫向下转型.向下转型是强制类型转换.
	5.2.1:语法:子类类型 变量名=(子类类型)父类变量;
	5.2.2:向下转型的适用场景:用父类作为数据类型,创建的子类对象,只能调用从父类继承的方法,或者从父类继承过来重写的方法,调不出子类独有方法,想调用子类独有的方法,就要向下转型.
		 eg:public static void main(String[] args) {
	//创建对象
	Pet p1=new Cat();
	Pet p2=new Dog();
	
	//用对象调用方法
	p1.bark();
	p1.eat();
	
	p2.bark();
	p2.eat();
	//用父类作为数据类型,创建的子类对象,只能调用从父类继承的方法,或者从父类继承过来重写的方法,调不出子类独有方法.
	//这时就需要用向下转型,将父类型的变量转换成子类原本的类型
	Cat c2=(Cat) p1;
	Dog d2=(Dog) p2;
	
	//用子类原来类型调用子类独有方法
	c2.catchMice();
	d2.watchDoor();
}

5.3:向下转型有风险,为了解决这个风险,在向下转型之前要进行类型判断
	语法:boolean result=变量名 instanceof 子类类型
	eg:public static void main(String[] args) {
	//创建对象
	Pet p1=new Cat();
	Pet p2=new Dog();
	
	//向下转型有风险,转换的类型有误会报类型转换异常,为了解决类型转换异常,转换之前先作类型判断
	if(p2 instanceof Dog) {
		Dog d2=(Dog) p2;
		d2.watchDoor();
	}else if(p2 instanceof Cat) {
		Cat d2=(Cat) p2;
		d2.catchMice();
	}
	
}