[java基础]面向对象(四)

多态：多种形态

向上造型/自动类型转换：

• 超类型的引用指向派生类的对象

• 能点出来什么，看引用的类型--------------这是规定，记住它

向下转型/强制类型转换，成功的条件只有如下两种：

• 引用所指向的对象，就是该类型

• 引用所指向的对象，实现了该接口或继承了该类

1. 强转时若不符合如上条件，则发生ClassCastException类型转换异常

   建议：在强转之前先通过instanceof来判断引用的对象是否是该类型

   注意：instanceof返回boolean结果，它为true的条件就是强转成功的条件

   何时需要强转：若想访问的属性/行为在超类中没有，则需要强制类型转换

   package test;//什么时候会用到向上造型,比如需要遍历每个动物,输出每个动物的名字(属性),每个动物吃饭喝水(行为)
   //什么时候用向下转型,在我们用了封装所有动物超类来向上造型实例化了每一个对象的时候,因为是用的超类指向,所有为了满足访问权限,需要向下造型为具体动物,来访问它的特有行为
   //例如:有一个动物类,用来封装所有动物的属性和行为
   public abstract class Animal {//封装所有代码共有的属性String name;int age;String color;Animal(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}void drink() {System.out.println(color + "色的" + age + "岁的" + name + "正在喝水...");}//普通方法,封装所有动物共有的行为,行为代码一样abstract void eat();//抽象方法,封装所有动物共有的行为,行为代码不一样
   }//有一个接口,用来封装部分动物共有的行为
   //用作演示同一个类中去掉其余public 原: public interface Swim
   interface Swim {/ 游泳 */void swim();//抽象方法 默认public abstract
   }//有一个狗狗类
   //用作演示同一个类中去掉其余public 原: public class Dogclass Dog extends Animal implements Swim {Dog(String name,int age,String color){super(name,age,color);//必须继承超类构造器}void lookHome(){//狗狗自己的行为System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在看家...");}void eat(){//重写继承的抽象方法,和其他动物共有的行为,但不同System.out.println(color+"色的"+age+"岁的狗狗"+name+"正在吃肯头...");}public void swim(){//重写接口的抽象方法,部分动物共有的行为,必须加publicSystem.out.println(color+"色的"+age+"岁的狗狗"+name+"正在游泳...");}
   }//有一个鱼类
   //用作演示同一个类中去掉其余public 原: public class Fishclass Fish extends Animal implements Swim {Fish(String name,int age,String color){super(name,age,color);}void eat(){//重写继承的抽象方法,,和其他动物共有的行为,但不同System.out.println(color+"色的"+age+"岁的小鱼"+name+"正在吃小虾...");}public void swim(){//重写接口的抽象方法,部分动物共有的行为,必须加publicSystem.out.println(color+"色的"+age+"岁的小鱼"+name+"正在游泳...");}
   }//有一个鸡类
   //用作演示同一个类中去掉其余public 原: public class Chickclass Chick extends Animal {Chick(String name,int age,String color){super(name,age,color);}void layEggs(){//鸡自己的行为System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在下蛋...");}void eat(){//重写继承的抽象方法,,和其他动物共有的行为,但不同System.out.println(color+"色的"+age+"岁的小鸡"+name+"正在吃小米...");}
   }//有一个主人类
   //用作演示同一个类中去掉其余public 原: public class Masterclass Master {void feed(Animal animal){ //喂动物animal.eat();animal.drink();}void feed(Dog dog){ //喂动物dog.eat();dog.drink();}
   }//用作演示同一个类中去掉其余public 原: public class Testclass Test {public static void main(String[] args) {// 现在我想:输出每个动物的名字(属性),每个动物吃饭喝水(行为),便需用用到向上造型// Animal animal=new Animal();报错,不能实例化抽象类Animal[] animals=new Animal[4];//通过超类Animal数组对象,封装所有动物对象animals[0]=new Dog("小狗",23,"黄色");//这里便需用用到向上造型,给每一个动物赋值,生成每一个实例化动物对象animals[1]=new Chick("小鸡1",2,"黄色");animals[2]=new Chick("小鸡2",2,"花色");animals[3]=new Fish("小鱼",1,"金色");for (int i = 0; i < animals.length; i++) {System.out.println(animals[i].name);//输出每个动物的名字animals[i].eat();//每个动物吃饭animals[i].drink();//每个动物喝水}//如果此时还想让其中的狗狗能看家,鸡能下蛋for (int i = 0; i < animals.length; i++) {if(animals[i]instanceof Dog){//如果是狗狗(如果有狗狗)Dog dog=(Dog)animals[i];//向下转型,因为能.出来什么得看引用的类型,只有狗狗类能访问lookHome所以需要向下转型来访问dog.lookHome();}if(animals[i]instanceof Chick){Chick chick=(Chick) animals[i];chick.layEggs();}}//如果现在想实现:有一个主人,想喂所以动物(向上造型的第二个应用,传参)Master master=new Master();//实例化一个主人对象Dog dog=new Dog("小狗",1,"黄色");//有一条狗Fish fish=new Fish("小鱼",2,"金色");//有一条鱼Chick chick=new Chick("小鸡",1,"花色");//有一只鸡master.feed(dog);//主人行为,喂狗,这里传的参是Dog类master.feed(fish);//主人行为,喂鸡,这里传的参是Animal类,自动做了向上造型,把Fish类造型为Animal类传入Animal o = new Dog("小黑",2,"黑");Swim s=(Swim)o;//接口也可以建对象,向下转型,因为能.出来什么得看引用的类型,只有实现了游泳的狗狗类能访问swim所以需要向下转型来访问s.swim();//用狗狗访问游泳接口的游泳行为Swim ss=new Swim() {//拓展:接口不能实例化,这里的ss对象是接口的派生类对象.@Overridepublic void swim() {System.out.println("游泳");}};ss.swim();//Fish f = (Fish)o; //运行时会发生ClassCastException类型转换}}

成员内部类：应用率低

• 类中套类，外面的称为外部类，里面的称为内部类

• 内部类通常只服务于外部类，对外不具备可见性

• 内部类对象通常在外部类中创建

• 内部类可以直接访问外部类的成员，在内部类中有个隐式的引用指向创建它的外部类对象

  隐式的引用：外部类名.this

• 何时用：若A类(Baby)只让B类(Mama)用，并且A类(Baby)还想访问B类(Mama)的成员时，可以设计成员内部类

public class leibulei {public static void main(String[] args) {M m=new M();m.create();//可以直接传递输出到王五,王五//B b = new B(); //编译错误，内部类对外不具备可见性}
}class M{//外部内String name="王五";void create(){B b=new B();//内部类对象通常在外部类中创建b.show();}class B{//内部类void  show(){System.out.println(name);//简写,可以访问外部类属性System.out.println(M.this.name); //完整写法,Mama.this指外部类对象//System.out.println(this.name);}}
}

匿名内部类：应用率高

• 何时用：若想创建一个派生类的对象，并且对象只创建一次，可以设计为匿名内部类，可以大大简化代码

• 注意：匿名内部类中不能修改外面局部变量的值

• 小面试题：

  • 问：内部类有独立的.class吗?

  • 答：有

public class AnonInnerClassDemo {public static void main(String[] args) {//1)创建了Aoo的一个派生类，但是没有名字//2)为该派生类创建了一个对象，名为o1，向上造型为Aoo类型//  ----new Aoo(){};是在创建Aoo的派生类对象//3)大括号中的为派生类的类体Aoo o1=new Aoo() {};//1)创建了Aoo的一个派生类，但是没有名字---另一个派生类了//2)为该派生类创建了一个对象，名为o2，向上造型为Aoo类型//3)大括号中的为派生类的类体Aoo o2 = new Aoo(){};int num = 5;num = 6;//1)创建了Boo的一个派生类，但是没有名字//2)为该派生类创建了一个对象，名为o3，向上造型为Boo类型//3)大括号中的为派生类的类体Boo o3 = new Boo(){void show(){ //重写Boo类的show()方法System.out.println("showshow");//num = 55; //编译错误，匿名内部类中不能修改外面局部变量的值}};o3.show(); //通过派生类对象o3来调用派生类类体中的show()方法}}abstract class Boo{abstract void show();
}
abstract class Aoo{}

package ooday04;
import java.util.Timer;
import java.util.TimerTask;
//匿名内部类的练习----定时器(定时做任务)
public class TimerDemo {public static void main(String[] args) {Timer timer = new Timer(); //定时器对象int interval = 1000; //定时间隔(以毫秒为单位)//定闹表7点响只需要定1次，可以设计为匿名内部类对象timer.schedule(new TimerTask() {public void run() { //定时干的事---每1000毫秒自动执行System.out.println("该练代码啦!!!!!");}}, interval, interval); //定时计划表}
}

package和import：

• package：声明包

  1. 作用：避免类的命名冲突

  2. 规定：同包中的类不能同名，但不同包中的类可以同名。

  3. 类的全称：包名.类名。包名常常有层次结构

  4. 建议：包名所有字母都小写

• import：导入类

  • 同包中的类可以直接访问，但不同包中的类不能直接访问，若想访问：

    1. 先import导入类，再访问类--------------建议

    2. 类的全称---------------------------------------太繁琐、不建议

注:

多态的实际应用：

• 将不同对象(狗、鱼、鸡)统一封装到一个数组(动物数组)中来访问，实现代码复用

• 将超类型(Animal)作为参数或返回值类型，传递或返回派生类(Dog/Fish/Chick)对象，以扩大方法的应用范围(所有Animal)，实现代码复用

隐式的引用：

• this：指代当前对象

• super：指代当前对象的超类对象

• 外部类名.this：指代当前对象的外部类对象