【JAVA学习笔记】45 - （35 - 43）第十章作业

项目代码

https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter10/src/com/yinhai/homework10

1.静态属性的共享性质

判断下列输出什么

public class HomeWork01 {
    public static void main(String[] args) {
        Car c =new Car();//无参构造时改变color为red
        Car c1=new Car(100);//price改为100，是c1对象的值
        System.out.println(c);//out 9 red
        System.out.println(c1);//out 100 red

    }
}
class Car{
    double price=10;
    static String color="white";//静态方法，共享属性
    public String toString(){
        return price+"\t"+color;
    }
    public Car(){
        this.price=9;
        this.color="red";
    }
    public Car(double price){
        this.price=price;
    }
}

2.静态私有属性

1.在Frock类中声明私有的静态属性currentNum[int类型]，初始值为100000，作为衣服出厂的序列号起始值。

2.声明公有的静态方法getNextNum,作为生成上衣唯序列号的方法。每调用一次，将
currentNum增加100,并作为返回值

3.在TestFrock类的main方法中，分两次调用getNextNum方法，获取序列号并打印输出。

4.在Frock类中声明serialNumber(序列号)属性，并提供对应的get方法;

5.在Frock类的构造器中，通过调用getNextNum方法为Frock对象获取唯- -序列号，赋给
serialNumber属性。

6.在TestFrock类的main方法中，分别创建三个Frock对象，并打印三个对象的序列号，验
证是否为按100递增。

满简单的练习使用静态方法和属性练练

/**
 * @author 银海
 * @version 1.0
 */
public class HomeWork02 {
    public static void main(String[] args) {
        System.out.println(Frock.getNextNum());
        System.out.println(Frock.getNextNum());
        Frock frock = new Frock();
        Frock frock1 = new Frock();
        Frock frock2 = new Frock();
        System.out.println(frock.getSerialNumber());
        System.out.println(frock1.getSerialNumber());
        System.out.println(frock2.getSerialNumber());


    }
}
class Frock{
    private static int currentNum = 100000;
    private int serialNumber;

    public static int getNextNum(){
        currentNum += 100;
        return currentNum;
    }

    public Frock() {
        getNextNum();
        serialNumber = currentNum;
    }

    public int getSerialNumber() {
        return serialNumber;
    }
}

3. 抽象类方法的调用

按要求实现下列问题:

1.动物类Animal包含了抽象方法shout();

2. Cat类继承了Animal,并实现方法shout,打印“猫会喵喵叫"

3. Dog类继承了Animal,并实现方法shout,打印“狗会汪汪叫”

4.在测试类中实例化对象Animal cat =new Cat,并调用cat的shout方法

5.在测试类中实例化对象Animal dog=new Dog.并调用dog的shout方法

也蛮简单的练习使用抽象类

/**
 * @author 银海
 * @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{
    public abstract void shout();
}
class Cat extends Animal{
    public void shout(){
        System.out.println("猫喵喵叫....");
    }
}
class Dog extends Animal{
    public void shout(){
        System.out.println("狗汪汪叫....");
    }
}

4.匿名内部类的使用

1.计算器接口具有work方法，功能是运算，有一个手机类Cellphone, 定义方法testWork测试计算功能，调用计算接口的work方法

//注意这里只是调用计算接口的work方法，而不是cellphone类去实现接口，因为实际需求中计算器功能是可变的，可以重写work方法然后类去实现接口，但这样本质上保证不了可变性，我们的计算方法是固定的。那么怎么解决这个问题呢，使用匿名内部类重写接口方法

2.要求调用CellPhone对象的testWork方法，使用上匿名内部类

/**
 * @author 银海
 * @version 1.0
 */
public class HomeWork04 {
    public static void main(String[] args) {
        CellPhone cellPhone = new CellPhone();
        cellPhone.textWork(new ICalculator() {
            @Override
            public double work(double n1, double n2) {
                return n1 + n2;
            }
        },10,18);
        cellPhone.textWork(new ICalculator() {
            @Override
            public double work(double n1, double n2) {
                return n1 * n2;
            }
        },10,18);
    }
}

interface ICalculator {
    double work(double n1 ,double n2);//接口是抽象类 不能有方法体 实现的work只是调用时的规范
}

class CellPhone {
    public void textWork(ICalculator iCalculator,double n1,double n2){
        //传入的iCal实际上运行类型是一个叫ICalculator$1的一个类
        //动态绑定之后，运行的是$1也就是匿名类的方法体，也就是说我们可以使用一次而且自己随意改变方法体的内容
        double res = iCalculator.work(n1,n2);//动态绑定
        System.out.println("结果为" + res);
    }
}

拿下！

5.局部内部类和成员内部类

1.编一个类A，在类中定义局部内部类B，B中有一个私有常量name,有一个方法show（）打印常量name.进行测试

2.进阶: A中也定义一个私有的变量name,在show方法中打印测试

/**
 * @author 银海
 * @version 1.0
 */
public class HomeWork05 {
    public static void main(String[] args) {
        A a = new A();
        a.new B().show();
        a.f1();
    }
}
class A {
    private String name = "我是外部类的name";
    class B{
        private String name = "我是内部类的name";
        public void show(){
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(B.this.name);
            System.out.println(A.this.name);
            //其实可以看做我们对象名前的类名限定了对象的访问范围
        }//如果想要打印，外部类的name变量，可以使用类名.this.name;
    }//如果想要访问成员内部类的show方法 需要编写方法返回一个成员内部类的对象然后嗲用
    //或者是在外部其他类直接调用
    //如果是局部内部类，需要写在方法内
    public void f1(){
        class B{
            private String name = "我是局部内部类";
            public void show(){
                System.out.println(name);
                System.out.println(this.name);
                System.out.println(A.this.name);

            }
        }
        //如果想在外部其他类访问局部内部类 需要在方法体内创建对象
        new B().show();
    }
}

6.接口类和类等等的设计思路

可以多看看这个作业，对接口和调用接口类的了解可以更上一层楼

1.有一个交通工具接口类Vehicles,有work接口

2. 有Horse类和Boat类分别实现Vehicles

3.创建交通工具工厂类，有两个方法分别获得交通工具Horse和Boat

4.有Person类，有name和Vehicles属性，在构造器中为两个属性赋值

5.实例化Person对象"唐僧”，要求一般情况下用Horse作为交通工具，遇到大河时用Boat
作为交通工具

6.增加一个过火焰山，用飞机

分析

不太会写这个导图，表达不出来思路

public class HomeWork06 {
    public static void main(String[] args) {
        Person tangseng = new Person("唐僧");
        tangseng.walk();
        tangseng.walk();
        tangseng.passRiver();
        tangseng.passRiver();
        tangseng.walk();
        tangseng.passRiver();
        //添加一个过火焰山的 正常来说就过一次火焰山，用一次飞机，所以直接用匿名内部类
        //分析应该是基于接口的匿名内部类，内部重写work方法，这个匿名对象只创建一次
        tangseng.flightFlamesMountain();

    }
}
class Person{
    private String name;
    private Vehicles vehicles;

    public Person(String name) {
        this.name = name;
        this.vehicles = Horse.HORSE;
    }
    public void walk(){
        System.out.println("=================");
        System.out.println("走路的时候用马");
        if(!(vehicles instanceof Horse)){//还需要判断一下目前是不是马，是马就不用getHorse
            System.out.println("现在还不是马 骑上白龙马赶路");
            vehicles = VehFactory.getHorse();
        }else{
            System.out.println("现在依然是马，接着赶路");
        }
        vehicles.work();
        System.out.println("=================");
    }
    public void passRiver(){
        System.out.println("=================");
        System.out.println("过河的时候用船");
        if(!(vehicles instanceof Boat)){//还需要判断一下目前是不是船，是船就不用getBoat
            System.out.println("现在还不是船 借一艘船过河");
            vehicles = VehFactory.getBoat();
        }else{
            System.out.println("现在依然是船，接着过河");
        }
        vehicles.work();
        System.out.println("=================");
    }
    public void flightFlamesMountain(){
        System.out.println("=================");
        System.out.println("过火焰山的时候用飞机");
        vehicles = new Vehicles() {
            @Override
            public void work() {
                System.out.println("飞机呼呼飞");
            }
        };
        vehicles.work();
        System.out.println("=================");
    }

}
interface Vehicles{//定义规范 以及方便调用
    void work();
}
class VehFactory{
    public static Horse getHorse(){
        return Horse.HORSE;
    }
    public static Boat getBoat(){
        return new Boat();
    }
}
class Horse implements Vehicles{//需要符合规范而且实现接口
    private String name;
    public static final Horse HORSE = new Horse("白龙马");
    //唐僧骑的是白龙马 所以应该是固定的一匹马
    private Horse(String name){
        this.name = name;
    }
    @Override
    public void work() {
        System.out.println("小马走呀走");
    }
}
class Boat implements Vehicles{//需要符合规范而且实现接口
    @Override
    public void work() {
        System.out.println("小船划呀划");
    }
}

7.成员内部类的使用

有一个Car类，有属性temperature (温度)车内有Air (空调)类，有吹风的功能flow,Air会监视车内的温度，如果温度超过40度则吹冷气。如果温度低于0度则吹暖气，如果在这之间则关掉空调。实例化具有不同温度的Car对象，调用空调的flow方法，测试空调吹的风是否正确。

很简单练练成员内部类的实例化

/**
 * @author 银海
 * @version 1.0
 */
public class HomeWork07 {
    public static void main(String[] args) {
        Car car = new Car(500);
        car.useAir();
        Car car1 = new Car(-500);
        car1.useAir();
        Car car2 = new Car(5);
        car2.useAir();
        //注意 成员内部类的使用还可以
        car.new Air().flow();//这么用，但是为了方便懒得这样用，在Car内做一个方法useAir，在里面new Air().flow();
    }
}
class Car{
    private int temperature;

    public Car(int temperature) {
        this.temperature = temperature;
    }

    class Air{
        public void flow(){
            if(temperature > 40){
                System.out.println("冷风");
            }else if(temperature < 0){
                System.out.println("热风");
            }
            else{
                System.out.println("不吹");
            }
        }
    }
    public void useAir(){
        new Air().flow();
    }
}