Java基础6-多态;匿名内部类;适配器模式

昨日内容回顾

1. 类成员

   • 构造函数：和类同名，没有返回值，可以重载
     this(),super()
   • 成员变量：
   • 成员函数：
   • 静态代码块：类加载执行
   • {}：构造代码块

2. interface

   • 所有方法都是抽象的

   • 属性有固定的修饰符.

   • 接口之间是继承关系，可以多重继承

   • 类和接口之间是实现关系，类可以实现多个接口

       class A implements B,C,D
     

   • 面向接口编程降低耦合度.

3. 抽象类

   • abstract class
   • 抽象方法没有方法体，所在的类必须抽象类。
   • 抽象类可以没有抽象方法。
   • 不能实例化，有构造函数

4. final

   • 修饰类，类不能被继承

   • 修饰方法，方法不能被重写

   • 修饰变量，不能被修改，常量

5. 内部类

   • 成员位置：Benz$Engine

   • 方法内部：Benz$nEngine

6. 继承
   extends: 单重继承，多层继承

作业解析

1. 文字阐述静态代码块的作用。
   答：静态代码块在类加载时执行，且只执行一次，静态代码块用于初始化类。

2. 构造代码块与构造函数的调用顺序如何？和方法的声明位置是否有关？为什么？构造代码块的作用是什么？
   答：构造代码块与构造函数是同一级别的，不管声明顺序如何，构造对象时先按序调用构造代码块，然后才调用构造函数。构造代码块的作用是给对象统一初始化数据

3. 类加载时，是否一定会执行静态代码块？如何手动控制类加载？
   答：不一定，可以通过Class.forName(String,boolean initialize, ClassLoder)方法手动控制

4. 定义类Person,Man,Woman形成继承关系。

    class Person{
        String name;
        int age;
    }
    
    class Man extends Person{
    }
    
    class Woman extends Person{
    }
   

5. 什么是抽象方法？什么是抽象类？抽象类是否有构造函数，是否可以重载？
   答：没有方法体的方法就是抽象方法，用abstract修饰， 抽象类是不能够实例化的类，用abstract修饰，有构造函数，可以重载

6. 抽象修饰符有哪些非法组合？并给出合理的解释？
   答：

   • private abstract: abstract修饰的方法需要子类去实现，若定义为private，则无法被子类继承，更别说实现了
   • final abstract: final修饰的方法不能被重写，也就无法实现
   • static abtract: 用abtract修饰的目的就是不想让方法被实例化对象调用，static则不需要实例化就可以调用类的方法，与abstract设计的初衷不符

7. super和this作用以及用法以及注意事项？
   答：

   • super是指向父类的引用。访问父类构造用super(xxx)，必须在构造函数第一行，访问父类属性和方法使用super.
   • this是指向对象自身的引用。访问自身属性和方法使用this.,访问自身构造使用this(xxx)，且必须放置在构造函数的首行。

8. 定义接口

   • IWhite

       interface IWhite{
           public void iWhite();
       }
     

   • IRich

       interface IRich{
           public void iRich();
       }
     

   • IBeanti

       interface IBeanti{
           public void iBeanti();
       }
     

   • 定义类，实现以上三个接口.(WomenStar)

       interface IWRB extends IWhite,IRich,IBeanti{
       }
       
       class WomenStar implements IWRB{
           public void iWhite(){
               System.out.println("white");
           }
           public void iRich(){
               System.out.println("rich");
           }
           public void iBeanti(){
               System.out.println("beanti");
           }
       }
     

   • 定义土豪类(EarchRicher.marring(...))

       class EarchRicher{
           public void marring(IWRB i){
               i.iWhite();
               i.iRich();
               i.iBeanti();
           }
       }
     

多态

1. 多态就是多种状态（形态）
   对继承的类来讲，使用父类类型引用子类的对象;
   对于接口来说，可以使用接口引用实现了该接口的类所创建的对象;

2. 好丈夫 + 好父亲 + 好儿子
   ClassCastException：类转换异常

3. 继承和实现是多态的前提条件

4. 类中方法可以覆盖，成员变量（资产）不能覆盖

    class Person{
        public int prop ;	//财产
    }
   
    class Man extends Person{
        public int prop ;	//
    }
   
    public static void main(String[] args){
        Man man = new Man();
        Person p = man ;
   
        Object obj = new Man();
        Person pp = (Man)obj ;
    }
   

匿名内部类对象

将类的定义，方法的实现，对象的创建一气呵成

适配器模式

1. 如果接口中的方法较多，而使用接口的时候却只关心其中的一个或者几个方法（关心的方法较少）;

2. 如果采用常规手段，就需要对每个方法都加以实现。可以创建一个类来实现接口，对不关心的方法进行空实现，对关心的方法保持不变。定义的新类继承抽象类后，将所关心的方法加以实现即可。

此种模式就称为适配器模式。常用于UI设计中的按钮点击事件的处理

练习

1. 定义Father类，声明asset int私有属性，同时生成get/set方法。
2. 定义Son类继承Father，声明asset int私有属性，同时生成get/set方法。
3. 创建Son对象，分别使用Father和Son类型的变量进行引用，依次调用

他们的setAsset()方法，然后再依次调用getAsset()方法，观察打印数据是否相同?

class Father{
    //私有财产
    private int asset = 10000;

    //getter
    public int getAsset(){
        return asset ;
    }

    //setter
    public void setAsset(int asset)	{
        this.asset = asset ;
    }
}


class Son extends Father{
    public int asset = 100;

    public void setAsset(int asset){
        this.asset = asset ;
    }

    public int getAsset(){
        return asset ;
    }

    public int getFatherAsset(){
        return super.getAsset();
    }
}

class MultiDemo3{
    public static void main(String[] args){
        Son s = new Son();
        s.setAsset(500);			//若setAsset()没有被重写，则 father.asset = 500;若setAsset()被重写，则self.asset = 500
        System.out.println(s.getAsset());	//若getAsset()没有重写，则==10000;若getAsset()被重写，则==500
        System.out.println(s.asset);		//若setAsset()没有被重写==100;若setAsset()被重写==500;
        System.out.println("--------");		

        Son ss = new Son();
        Father ff = ss ;
        ff.setAsset(800);//若setAsset()没有被重写，则father.asset = 800;若setAsset()被重写，则son.asset = 800;
        System.out.println(ss.asset);// 800

        ss.setAsset(900);//若setAsset()没有被重写，则father.asset = 900;若setAsset()被重写，则son.asset = 900;
        System.out.println(ff.getAsset());	//若getAsset()没有重写，则==10000;若getAsset()被重写，则==900
        System.out.println(ss.getFatherAsset());//10000
    }
}

作业

1. 使用接口进行如下程序设计
   个人电脑(PC)具有PCI插槽，可以插入PCI卡。显卡、声卡、语音卡都可以作为PCI卡插入PCI插槽中
   PC,PCI,slot,VideoCard,SoundCard, VoiceCard

2. 高富帅
   Height
   Rich
   Handsome
   Girl boyFriend(HRH h)
   用匿名内部类实现

3. 使用适配器模式实现窗口的事件处理程序
   窗口可以响应最大化事件、最小化事件、大小改变事件、恢复事件、移动事件、关闭事件
   通过适配器对大小改变事件、移动事件和关闭进行默认处理，窗口只关心最大化和最小化事件即可。
   Window
   WindowListener{max min resize restore move close}

4. 使用抽象类和接口实现适配器模式设计。涉及的类和接口分别为ButtonListener(接口),
   其中含有click() / dbclick() / keyUp() / keyDown()等方法。
   ButtonAdapter(按钮适配器类)，适配器中对非click()方法进行默认实现。
   Button类中添加addListener(ButtonListener l)方法。

5. 阐述什么是多态。
   为什么函数可以覆盖，而属性不能覆盖？