Java学习 第十二天

第一章 多态

1.1 多态的概述

注意：
1.继承性指的是以下三种： 类与类之间的继承extends，类与接口之间的实现implements，接口与接口之间的extends
2.多态性： 多态性是指对象的多态性，注意是针对对象而言的。

1.2 多态的格式与使用

代码当中体现多态性，其实就是一句话，父类指向子类引用对象
格式：

父类名称 对象名 = new 子类名称();

或者

接口名称 对象名 = new 实现类名称();

1.2.1 多态中成员变量的使用特点（和继承当中完全一样）

两种情况：
1.当采用对象直接访问成员变量时，看创建对象时，等式左边是谁，就优先用谁

//	定义父类
public class Fu {
    int  num = 10;
}

//	定义子类
public class Zi extends Fu{
    int num = 20;
}

//	定义测试类
public class Demo01MultiField {
    public static void main(String[] args) {
        //  使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();
        System.out.println(obj.num);    //  父：10
}

2.间接通过成员方法访问成员变量：看该方法属于谁，就优先用谁当中的变量，没有则向上查找

//	定义父类
public class Fu {
    int  num = 10;

    //  这个方法是父类的，所以优先使用父类里的num，不会向下查找
    public void showNum(){
        System.out.println(num);
    }

//	定义子类
public class Zi extends Fu{
    int num = 20;
    int age = 16;

    @Override
    //  这个方法是子类的，所以优先使用子类里的num，如果子类没有再向上查找父类当中有无num
    public void showNum(){
        System.out.println(num);
    }

//	定义测试类
public class Demo01MultiField {
    public static void main(String[] args) {
        //  使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();
        System.out.println(obj.num);    //  父：10
//        System.out.println(obj.age);  //  错误写法，通过对象名访问成员变量是看等号左边的，在这种多态方式下也就是看父类，而不会向下查看子类
        System.out.println("=====================");

        //  子类没有覆盖重写，就是父：10
        //  子类如果覆盖重写，就是子：20
        obj.showNum();
    }
}

总结： 编译看左，运行还看左。 因此，若父类当中没有相应的变量，则程序会编译不通过，也就是无法访问子类特有的属性。

1.2.2 多态中成员方法的使用特点

规则： 看创建对象时候new的是谁，就优先用谁
记忆口诀： 编译看左，运行看右
口诀理解： 在使用多态方式调用方法时，首先查看父类当中有无相应的方法，若有，则执行子类当中进行重写或继承下来的相应方法。若父类当中无相应的方法，则编译报错。 所以，多态创建的对象，无法访问子类特有的方法

//	定义父类
public class Fu {
    int  num = 10;

    //  这个方法是父类的，所以优先使用父类里的num，不会向下查找
    public void showNum(){
        System.out.println(num);
    }

    public void method(){
        System.out.println("父类方法");
    }

    public void methodFu(){
        System.out.println("父类特有方法");
    }
}

//	定义子类
public class Zi extends Fu{
    int num = 20;
    int age = 16;

    @Override
    //  这个方法是子类的，所以优先使用子类里的num，如果子类没有再向上查找父类当中有无num
    public void showNum(){
        System.out.println(num);
    }

    @Override
    public void method(){
        System.out.println("子类方法");
    }


    public void methodZi(){
        System.out.println("子类特有方法");
    }
}

//	定义测试类
public class Demo02MultiMethod {
    public static void main(String[] args) {
        Fu obj = new Zi();  //  多态

        obj.method();   //  父子都有，new的是子所以优先用子
        obj.methodFu(); //  子类没有，父类有，向上查找到父类（也可以理解为从父类当中继承下来）

        //  编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。
//        obj.methodZi();  // 错误写法
    }
}

1.3 使用多态的好处和弊端

好处：

弊端：
多态创建的对象无法使用子类特有的内如（属性，方法）

1.4 对象的向上转型

多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

对比数据类型的转换,就好像是：
double a = 10;
左边定义的是double类型的变量a，但右边赋值的是一个int类型的10，这时会发生数据的类型转换，由于是从小范围到大范围所以一定是安全的，是默认的。

注意：
Java在创建对象时候也是可以像创建数组、基本数据类型变量一样采用两步走的方式。，也就是先声明，再创建
（1）对象的声明：类名 对象名
（2）对象的创建：对象名 =new 类名（）

当父类引用指向一个子类对象时，便是向上转型。

// 定义父类Animal
public abstract class Animal {
    public abstract void eat();
}

//	定义子类Cat
public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }

    //  子类特有方法
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

//	定义测试类
public class Demo01Main {
    public static void main(String[] args) {
        //  对象的向上转型，就是父类引用指向子类对象
        Animal animal = new Cat();  //  本来创建的时候是一只猫
        animal.eat();	//	猫吃鱼

//        animal.catchMouse;  //  按照访问成员方法的规则来看，编译看左则编译不会进行通过，因此是错误写法！
}

向上转型的弊端： 对象一旦向上转型为父类，那么就无法调用子类原本特有的内容

解决方案： 将已经进行向上转型的对象再次转换为原本的子类对象，也即是 【向下转型】

1.5 对象的向下转型

概念： 父类类型向子类类型向下转换的过程，这个过程是强制的。
转换格式：

子类名称 变量名 = （子类名称） 父类变量名；

//	定义父类Animal
public abstract class Animal {
    public abstract void eat();
}

//	定义子类Cat
public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }

    //  子类特有方法
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

//	定义子类Dog
public class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("狗吃肉");
    }

    public void watchHouse(){
        System.out.println("狗看家");
    }
}

//	定义测试类
public class Demo01Main {
    public static void main(String[] args) {
        //  对象的向上转型，就是父类引用指向子类对象
        Animal animal = new Cat();  //  本来创建的时候是一只猫
        animal.eat();

//        animal.catchMouse;  //  错误写法！

        //  向下转型，进行“还原”动作
        Cat cat = (Cat) animal;
        cat.catchMouse();   //  猫抓老鼠

        //  下面是错误的向下转型
        //  本来new的时候是一只猫，现在非要当做狗
        //  错误写法！编译不会报错，但是运行会产生异常
        //  java.lang.ClassCastException,类转换异常
//        Dog dog = (Dog) animal;

    }
}

注意： 上面所说的向上转型，向下转型等规则，不仅适用于父类和子类的转换，也适用于接口和实现类之间的转换。

1.6 instanceof关键字

在进行向下转型的时候，很有可能忘记转型错误而发生ClassCastException。如以下代码：

//	定义父类
public class abstract Animal{
	public abstract void eat();
}

//	定义子类Cat
public class Cat extends Animal{
	@Override
	public void eat(){
		System.out.println("猫吃鱼);
	}
	public void catchMouse(){
		System.out.println("猫抓老鼠");
	}
}

//	定义子类Dog
public class Dog extends Animal{
	@Override
	public void eat(){
		System.out.println("狗吃肉");
	}

	public void watchHouse(){
		System.out.println("狗看家");
	}
}

//	定义测试类
public class Demo01{
	public static void main(String[] args){
		//	使用多态创建一个对象
		Animal animal = new Cat();
		animal.eat();	//	猫吃鱼
		animal.catchMouse();	//	猫抓老鼠

		//	向下转型
//		Dog d = (Dog) animal;	//	转型的不是原本的Cat，而是Dog
//		d.eat();
//		d.watchHouse();	//	调用的是Dog的方法watchHouse
	
	}
}

上面的代码在进行编译的时候是不会报错的，但是在运行的时候会报出ClassCastException错误，也即是类型转换异常！ 这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为此，Java提供了instanceof关键字来进行检验一个对象能否看做某一个类型，从而来进行正确的向下转型。
instanceof关键字使用格式如下：

变量名	instanceof	数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。

对刚才的代码块进行修正如下：

//	定义父类
public class abstract Animal{
	public abstract void eat();
}

//	定义子类Cat
public class Cat extends Animal{
	@Override
	public void eat(){
		System.out.println("猫吃鱼);
	}
	public void catchMouse(){
		System.out.println("猫抓老鼠");
	}
}

//	定义子类Dog
public class Dog extends Animal{
	@Override
	public void eat(){
		System.out.println("狗吃肉");
	}

	public void watchHouse(){
		System.out.println("狗看家");
	}
}

//	定义测试类
public class Demo01{
	public static void main(String[] args){
		//	使用多态创建一个对象
		Animal animal = new Cat();
		animal.eat();	//	猫吃鱼

		//	向下转型
		if(animal instanceof Cat){
			Cat cat = (Cat) animal;
			cat.catchMouse();
		}else if(animal instanceof Dog){
			Dog dog = (Dog) animal;
			dog.watchHouse();
		} 
	}
}

第二章 final关键字

2.1 概述

final关键字代表最终的，不可改变的。

不可变： 对于基本数据类型来说，不可变是指变量当中的数据不可变。对于引用数据类型来说，不可变说的是变量当中的地址值不可改变

final关键字有四种常见用法：

• 用来修饰一个类
• 用来修饰一个方法
• 用来修饰一个局部变量
• 用来修饰一个成员变量

2.2 final关键字用来修饰一个类

格式：

public final class 类名称{
	...
}

当一个类用final关键字进行修饰时，意味着这个类不能有任何的子类，同时也意味着这个类里的所有方法都无法进行重写。（太监类）但是，这个类可以有父类。

2.2 final关键字用来修饰一个方法

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。因此，不难理解。对于类和方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

格式：

修饰符 final 返回值类型 方法名称(参数列表){
    //  方法体
}

2.3 final关键字来修饰一个局部变量

一旦使用final用来修饰局部变量（可以是基本/引用数据类型），那么这个局部变量将只能赋值一次，且不能进行更改。类似于字符串.
当局部变量是基本数据类型时，就是其中的数据不能改变。当局部变量是引用数据类型时，就是其变量的地址值不能改变

代码演示如下：

//	定义Student类
public class Student {
    private String name;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

//	定义测试类
public class Demo01Final {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1);   //  10
        num1 = 20;
        System.out.println(num1);   //  20

        //  一旦使用final用来修饰“局部”变量（基本数据类型），那么这个局部变量将只能赋值一次，且不能进行更改。类似于字符串
        //  “一次赋值，终生不变”
        final int num2 = 200;
        System.out.println(num2);   //  200

//        num2 = 500;   //  错误写法！不能改变！
//        num2 = 200;   //  错误写法!

        //  正确写法,只要保证有唯一一次的赋值即可
        final int num3;
        num3 = 30;

        //  对于基本类型来说，不可变说的是变量当中的数据不可改变
        //  对于引用数据类型来说，不可变说的是变量当中的地址值不可改变
        Student stu1 = new Student("泰隆");
        System.out.println(stu1);   //  输出地址值
        System.out.println(stu1.getName()); //  泰隆
			
		//  stu1是一个Student类型的变量
        //  根据上面代码可知其当前保存的是一个Student对象的内存地址
        //  而下面这行代码意思是，等号右边是创建了一个新的Student对象
        //  结合起来看就是把这个new出来的对象的内存地址值交给这个Student类型的stu1变量
        //	下面这行代码可以理解为Student stu1和stu1 = new Student("艾瑞莉娅"); 这两行代码分开创建了一个对象
        //	有点像数组的两步走创建
        stu1 = new Student("艾瑞莉娅"); 
        System.out.println(stu1);   //  输出地址值
        System.out.println(stu1.getName());
        System.out.println("==============================");

		//  final用来修饰局部变量（引用数据类型）
        final Student stu2 = new Student("卡特琳娜");
//        stu2 = new Student("卡兹克");  //  错误写法，final的引用类型变量，其中的地址值不可改变
        System.out.println(stu2.getName()); //  卡特琳娜
        stu2.setName("卡特琳娜娜娜娜娜");
        System.out.println(stu2.getName()); //  卡特琳娜娜娜娜娜

    }
}

2.4 final关键字用来修饰一个成员变量【重点】

对于成员变量来说，如果使用final关键字，那么这个变量照样也是不可变
注意事项：
1.由于成员变量有默认值，所以用了final以后必须手动赋值，不会再给默认值了。
2.对于final的成员变量，要么通过直接赋值，要么通过“构造方法”赋值。二者选其一。
3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

代码演示：

public class Person {
    private final String name /*= "泰隆"*/;

    public Person() {
        name = "卡特琳娜";
    }

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

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

    public String getName() {
        return name;
    }