JAVASE基础（十）

一、关键字

1.instanceof关键字

instanceof关键字：判断一个对象是否属于指定的类型。

instanceof关键字的使用前提：判断的对象与指定的类型必须存在继承的关系，或者是实现的关系。

instanceof关键字的使用格式：

对象  instanceof 类名

2.final（最终）关键字

final关键字要注意的细节：
1. final关键字修饰一个基本类型变量时，该变量不能重新赋值。
2. final关键字修饰一个引用类型变量时，其引用重新指向新的对象。
3. final修饰一个方法时，该方法不能被重写。
4. final修饰一个类的时候，该类不能被继承。

常量的修饰符: public static final.

常量命名规范：所有字母大写，单词与单词之间使用下划线分隔。

3.abstract(抽象)关键字

抽象类的应用场景：
描述一类事物的时候，发现该事物确实存在着某种行为，但是目前该行为是不具体的，
那么这时候我们应该抽取该方法的声明，不去实现该方法，这时候我们应该使用抽象类。

抽象类要注意的细节：
1. 如果一个方法没有方法体，那么该方法必须使用abstract修饰。
2. 如果一个类有抽象的方法，那么该类也必须使用abstract修饰。
3. 非抽象类继承抽象类的时候，必须要把抽象类中的所有抽象方法全部实现。
4. 抽象类可以定义抽象方法以及非抽象方法。
5. 抽象类是可以不存在抽象方法的。
6. 抽象类不能创建对象。
疑问：为什么抽象类不能创建对象呢？
因为抽象类一旦创建了对象就可以使用对象去调用方法了，一旦调用了抽象方法就没有任何的意义了。
7. 抽象类是存在构造方法的。
疑问：既然抽象类不能创建对象，那么存在构造方法的意义在那？
抽象类的构造方法是留给子类调用初始化从父类继续下去的成员变量的。

abstract不能与以下关键字配合使用：
1. abstract 不能与private配合使用。
2. abstract 不能与final关键字配合使用。
3. abstract 不能与static关键字配合使用。

abstract class Animal{   String name;String color;public Animal(String name,String color){this.name= name; this.color = color;}//非抽象方法public void sleep(){}//移动...  抽象方法public abstract void run();
}//狗
class Dog extends Animal{public Dog(String name,String color){super(name,color);}//咬人public void bite(){System.out.println(name+"在狠狠的咬小贼");}public void run(){System.out.println(name+"四条腿跑得很快..");}
}class Bird extends Animal{public Bird(String name,String color){super(name,color);}public void fly(){System.out.println(name+"在飞翔...");}public void run(){System.out.println(name+"两条腿跑得很悠闲..");}}class Demo4 {public static void main(String[] args) {/* Dog d = new Dog("牧羊犬","棕色");d.bite();d.run();Bird b = new Bird("麻雀","灰色");b.fly();b.run();*/Animal a = new Animal("动物","彩色");}
}

二、接口

接口的定义格式：

interface 接口名{}

实现接口的格式：

class 类名 implements 接口{}

接口要注意的细节：
1. 接口其实是一个特殊的类。
2. 接口中的成员变量都是属于常量，默认的修饰符 public static final.
3. 接口中的方法都是抽象的方法，默认的修饰符： public abstract 。
4. 接口是不能用于创建对象。
5. 接口是没有构造方法的，因为接口中的变量都是常量，接口中方法都是抽象的方法。
6. 一个非抽象类实现一个接口时，必须实现接口中的所有方法。

接口的作用：
1. 程序的解耦。（低耦合）
2. 定义约束规范。
3. 拓展功能。

interface A{//成员变量public static final int i =10;void test();}//Demo9实现了A接口...
class Demo9  implements A{public static void main(String[] args) {//A a =  new A();Demo9 d  = new Demo9();d.test();}public void test(){System.out.println("这个接口的test方法...");}
}

接口与类之间的关系：实现关系.

要注意的细节：
1. 非抽象类实现一个接口时，必须要把接口中所有方法实现。
2. 一个类可以实现多个接口。
疑问： java支持多实现，为什么不支持多继承呢？
因为如果支持多继承的话，假设多个父类中有相同的成员，那么其子类就不搞清楚到底使用哪个父类的同名成员了.

3.  抽象类实现接口的时候， 可以实现接口中的方法，也可以不实现接口中的方法。

接口与接口之间关系：继承关系。

要注意细节：
1. 一个接口是可以继承多个接口。

三、多态

多态: 父类引用类型变量指向了子类的对象或者是接口的引用类型变量指向了接口实现类的对象。 (一个对象具备多种形态)

多态的前提：必须存在继承或者实现关系。

多态要注意的细节：
1. 多态情况下，子父类存在着同名的成员变量时，默认会访问父类的成员变量。
2. 多态情况下，子父类存在着同名的非静态函数时，默认是访问子类的成员函数。
3. 多态情况下，子父类存在着同名的静态函数时，默认是访问父类的成员函数。
4. 多态情况下，不能访问子类特有的成员。

总结：多态情况下，子父类存在同名的成员时，默认都会访问父类的成员.只有存在非静态的
同名函数时，才是访问子类的成员。

编译看左边，运行不一定看右边

编译看左边: java编译器在编译的时候，会检查引用类型变量所属的类是否具备指定的成员，如果
不具备，编译报错。

abstract class Animal{String name;String color;static  int age = 10;public Animal(String name,String color){this.name = name;this.color = color;}public abstract void run();public static void sleep(){System.out.println("动物睡觉...");}
}//狗
class Dog extends Animal{static int age = 20; public Dog(String name,String color){super(name,color);}public  void run(){System.out.println(name+"四条腿跑...");}public static void sleep(){System.out.println("狗在睡觉...");}//狗特有的方法public void bite(){System.out.println(name+"咬人");}}class Demo14
{public static void main(String[] args) {/*Dog d = new Dog("沙皮","棕色");d.run();*/Animal a = new Dog("哈士奇","白色");  //多态   父类的引用类型变量指向了子类的对象。//System.out.println("年龄："+ a.age);//a.sleep();a.bite();}
}

多态的应用场景：
1. 多态用于形式参数类型的时候，可以接收更多类型的参数。
2. 多态用于返回值类型的时候，可以返回更多类型的参数。

多态的好处：提高了程序的拓展性。

abstract class Car{String name;String color;public Car(String name,String color){this.name = name;this.color = color;}public abstract void run();
}//保时捷
class BSJ extends  Car{public BSJ(String name,String color){super(name,color);}public  void run(){System.out.println(name+"四个轮子飞快的跑...");}
}//三轮车
class ThreeCar extends Car{public ThreeCar(String name,String color){super(name,color);}public  void run(){System.out.println(name+"三个轮子离开地面跑起来..");}
}class BMW extends Car{public BMW(String name,String color){super(name,color);}public  void run(){System.out.println(name+"四个轮子安全跑起来..");}
}//修车厂
class CarFactory {public static void main(String[] args) {/*BSJ b = new BSJ("保时捷","红色");ThreeCar t = new ThreeCar("三轮车","红色");BMW bmw = new BMW("宝马","黑色");repair(bmw);*/Car c = saleCar(100);c.run();}//需求：定义一个修理的方法，该方法可以修理任何的车。public static void repair(Car c){ //  Car c = new BSJ("保时捷","红色");  多态System.out.println(c.name+"已经被修好了..");c.run();}//需求： 定义一个卖车方法,该方法可以返回任何类型的车对象。public static Car  saleCar(int money){if(money==100){return new ThreeCar("三轮车","红色");}else if(money==200){return new BSJ("保时捷","白色");}else{return new BMW("保时捷","白色");}}
}

多态情况下，不能访问子类特有的成员。

多态情况下如果需要调用到子类特有的成员，那么需要进行强制类型转换。

基本数据类型：

小数据类型----->大数据类型    自动类型转换大数据类型----->小数据类型    强制类型转换。

引用数据类型转换：

小数据类型----->大数据类型    自动类型转换大数据类型----->小数据类型     强制类型转换

异常： .ClassCastException 强制类型转换异常。引用类型变量做强制类型转换之前一般都会使用instanceof关键字先判断

abstract class Animal{String name;String color;public Animal(String name,String color){this.name = name;this.color = color;}public abstract void run();
}//鱼
class Fish extends Animal{public Fish(String name,String color){super(name,color);}public  void run(){System.out.println(name+"摇尾巴游啊游啊..");}//特有的方法public void bubble(){System.out.println(name+"在吹泡泡..");}}class Mouse extends Animal{public Mouse(String name,String color){super(name,color);}public  void run(){System.out.println(name+"四条腿大摇大摆的走!!");}//特有的方法public void dig(){System.out.println(name+"在挖洞...");}}class Demo5
{public static void main(String[] args) {//System.out.println("Hello World!");/*Animal a = new Fish("锦鲤","白色");  //自动类型转换Fish f = (Fish)a; //强制类型转换   相当于把动物看成了鱼f.bubble();*/Fish f = new Fish("锦鲤","白色");Mouse m  = new Mouse("竹鼠","棕色");print(m);}//需求： 定义一个方法可以接受任何类型的动物对象，在方法内部调用动物对象特有的方法。public static void print(Animal a){if(a instanceof Fish){Fish f= (Fish)a;f.bubble();}else if(a instanceof Mouse){Mouse m = (Mouse)a;m.dig();}}

实现关系下的多态：接口的引用类型变量指向了接口实现类的对象。

多态的前提：存在继承或者实现的关系。

interface Dao{public void add(String user);
}//接口中的方法全部都是非静态。 多态情况下，子父类存在同名的非静态函数时，默认是访问子类的非静态函数。class UserDao implements Dao{public void add(String user){System.out.println("添加用户"+user+"成功..");}
}class Demo6
{public static void main(String[] args) {//Dao d  我要一个符合dao接口规范的对象。Dao d = new UserDao(); //实现关系下的多态d.add("张三");}
}