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. 阐述什么是多态。
    为什么函数可以覆盖，而属性不能覆盖？

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/SweetZxl/p/9670418.html