JAVA面向对象编程作业（Chapter10、11）

第十章十一章作业

1.读代码

创建子类对象时在类的调用顺序

• 1.父类的静态代码块和静态属性初始化：优先级一样，按先后顺序调用
• 2.子类的静态代码块和静态属性初始化：优先级一样，按先后顺序调用
• 3.父类的普通代码块和普通属性初始化：优先级一样，按先后顺序调用
• 4.父类的构造方法
• 5.子类的普通代码块和普通属性初始化：优先级一样，按先后顺序调用
• 6.子类的构造方法

2.使用静态变量和静态方法时实现产品的唯一序列号编号

package com.chapter10_11;

/**
 * @author whj
 * @version 1.0
 */
public class Homework02 {
    public static void main(String[] args) {
        System.out.println( Frock.getCurrentNum());
        System.out.println( Frock.getCurrentNum());
        Frock frock01 = new Frock();
        System.out.println(frock01.getSerialNumber());
        Frock frock02 = new Frock();
        System.out.println(frock02.getSerialNumber());
        Frock frock03 = new Frock();
        System.out.println(frock03.getSerialNumber());

    }
}
class Frock{
    private static int currentNum = 100000;//衣服序列号起始值
    private int serialNumber;//当前序列号

    public Frock() {
        this.serialNumber = getCurrentNum();
    }

    public static int getCurrentNum(){//获得序列号
        return currentNum += 100;
    }

    public int getSerialNumber() {
        return serialNumber;
    }
}

3.抽象类的使用：继承含含有抽象方法的抽象类的子类必须实现抽象类

package com.chapter10_11;

/**
 * @author whj
 * @version 1.0
 */
public class Homework03 {
    public static void main(String[] args) {
        Animal cat = new Cat();
        cat.shout();
        Animal dog = new Dog();
        dog.shout();
    }
}
abstract class Animal{
    abstract void shout();
}
class Cat extends Animal{
    @Override
    void shout() {
        System.out.println("猫会喵喵叫");
    }
}
class Dog extends Animal {
    @Override
    void shout() {
        System.out.println("狗会汪汪叫。");
    }
}

4.匿名内部类的使用

语法：new interface/class（){};//相当于直接创建了类的对象，该类实现了接口功能，或是对类继承，重写方法。

package com.chapter10_11;

/**
 * @author whj
 * @version 1.0
 */
public class Homework04 {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();
        cellphone.testWork(new IA() {//匿名内部类
            @Override
            public void work() {
                System.out.println("功能是计算。");
            }
        });
    }
}
interface IA{
    void work();//接口的计算功能
}
class Cellphone  {
    public void testWork(IA ia){
        ia.work();//计算功能
    }
}

5.局部内部类

要求创建了外部类才能创建内部类

package com.chapter10_11;

/**
 * @author whj
 * @version 1.0
 */
public class Homework05 {
    public static void main(String[] args) {
        A a = new A();//先创建外部类
        A.B b = a.new B();//再创建内部类
        b.show();
    }
}
class A {
    private final String name = "zh";
    class B {
        private final String name = "whj";
        public void show(){
            System.out.println(A.this.name + name);
        }
    }
}

6.综合应用

• 不同的交通工具实现接口功能

• 工厂可以得到不同的工具

• 人有名字和交通工具两种属性，通过调用不同的方法获得不同的工具，实现不同的功能。

public class Homework06 {
    public static void main(String[] args) {
        Person tang = new Person("唐僧", Factory.getHorse());
        tang.common();
        tang.passRiver();
        tang.passMountain();
    }
}
//人
class Person {
    private String name;
    private Vehicles vehicles;

    public Person(String name, Vehicles vehicles) {
        this.name = name;
        this.vehicles = vehicles;
    }
    public void common(){
        //普通情况使用马
        if (!(vehicles instanceof Horse)){
            vehicles = Factory.getHorse();
        }
        vehicles.work();
    }
    public void passRiver(){
        if (!(vehicles instanceof Boat)){
            vehicles = Factory.getBoat();
        }
        vehicles.work();
    }
    public void passMountain(){
        if (!(vehicles instanceof Plane)){
            vehicles = Factory.getPlane();
        }
        vehicles.work();
    }
}
//工厂
class Factory {//工厂,返回交通工具
    //马只有一个。使用饿汉式创建马的实例对象
    private static Horse horse = new Horse();//内部创建对象

    private  Factory() {//构造器私有化
    }

    public static Horse getHorse(){//返回一个可以获取内部对象的
        return horse;
    }
    public static Boat getBoat(){//但是船每次都不同
        return new Boat();
    }
    public static Plane getPlane(){//飞机都不同
        return new Plane();
    }
}

//各个交通工具
class Plane implements Vehicles {
    @Override
    public void work() {
        System.out.println("过火焰山时，使用飞机。。。");
    }
}
class Horse implements Vehicles {
    @Override
    public void work() {
        System.out.println("一般情况，使用马儿。。。");
    }
}
class Boat implements Vehicles{
    @Override
    public void work() {
        System.out.println("过河时,使用小船。。。");
    }
}
//接口
interface Vehicles {
    void work();
}

7.外部其他类访问成员内部类

• 1.直接创建一个新的对象

• 2.内部类所处的外部类暴露一个获取内部类的方法。

  package com.chapter10_11;
  
  /**
   * @author whj
   * @version 1.0
   */
  public class Homework07 {
      public static void main(String[] args) {
          Car car = new Car(42.5);
          Car.Air air = car.new Air();//air 对象时固定的
          air.flow();
          System.out.println(air);
          car.setTemperature(-13);
          car.getAir().flow();
          System.out.println(car.getAir());
          car.setTemperature(13);
          air.flow();
          System.out.println(air);
  
      }
  }
  
  class Car {
      private double temperature;
      class Air {
          public void flow() {
              if (temperature > 40.0) {
                  System.out.println("空调吹冷风。");
              } else if (temperature < 0.0) {
                  System.out.println("空调吹暖风。");
              } else {
                  System.out.println("空调关闭。");
              }
          }
      }
  
      public Car(double temperature) {
          this.temperature = temperature;
      }
  
      public double getTemperature() {
          return temperature;
      }
  
      public void setTemperature(double temperature) {
          this.temperature = temperature;
      }
  
      public Air getAir() {//每次都是创建新对象
          return new Air();
      }
  }
  

8.枚举的使用switch

switch（）中，写入枚举对象，

在每个case之后，直接写上在枚举类中，当以的枚举对象即可。

package com.chapter10_11;

/**
 * @author whj
 * @version 1.0
 */
public class Homework08 {
    public static void main(String[] args) {
        Color color = Color.BLACK;
        color.show();
        switch (color) {
            case RED:
                System.out.println();
            case BLUE:
                System.out.println();
            default:
                System.out.println();
        }
    }
}
package com.chapter10_11;

/**
 * @author whj
 * @version 1.0
 */
public enum Color implements ShowColor{
    RED(255,0,0),BLUE(0,0,255),
    BLACK(0,0,0),YELLOW(255,255,0),
    GREEN(0,255,0);
    private int redValue;
    private int greenValue;
    private int blueValue;

    private Color(int redValue, int greenValue, int blueValue) {
        this.redValue = redValue;
        this.greenValue = greenValue;
        this.blueValue = blueValue;
    }

    public int getRedValue() {
        return redValue;
    }

    public int getGreenValue() {
        return greenValue;
    }

    public int getBlueValue() {
        return blueValue;
    }

    @Override
    public String toString() {
        return "Color{" +
                "redValue=" + redValue +
                ", greenValue=" + greenValue +
                ", blueValue=" + blueValue +
                '}';
    }

    @Override
    public void show() {
        System.out.println("redValue=" + redValue +
                ", greenValue=" + greenValue +
                ", blueValue=" + blueValue );
    }
}