标签：vehicles 静态 void 练习 System 枚举 println public out

1.静态代码块练习

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递增。

public class TestFrock {
    public static void main(String[] args) {

        int nextNum1 = Frock.getNextNum();
        System.out.println(nextNum1);//100100
        int nextNum2 = Frock.getNextNum();
        System.out.println(nextNum2);//100200

        System.out.println("========");
        Frock frock = new Frock();
        int serialNumber = frock.getSerialNumber();
        System.out.println(serialNumber);//100300


    }

}
class Frock{
    //静态属性是所有对象共享的
    private static int currentNum = 100000;
    private int serialNumber;

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

    public int getSerialNumber() {
        return serialNumber;
    }

    public static int getNextNum(){
        currentNum += 100;
        // 为什么不能直接写：return currentNum + 100;
        return currentNum;
    }
}

2.抽象方法练习题

按要求实现下列问题:

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

2.Cat类继承了Animal，并实现方法shout,打印“猫会瞄哺叫”

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

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

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

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("狗会汪汪叫");
    }
}

3.匿名内部类的使用

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

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

/**
 * @auther yt
 * @address https://www.cnblogs.com/y-tao/
 */
public class Homework04 {
    public static void main(String[] args) {
        //1.匿名内部类是
        /*
        new Calculator() {
            @Override
            public double work(double n1, double n2) {
                return n1 + n2;
            }
        }
         */
        //1.同时也是一个对象，他的编译类型是Calculator,而运行类型就是匿名内部类

        // 匿名内部类经典的应用场景就是作为参数列表
        CellPhone cellPhone = new CellPhone();
        //参数是实现了接口的匿名内部类，动态绑定到重写的work方法
        cellPhone.testWork(new Calculator() {
            @Override
            public double work(double n1, double n2) {
                return n1 + n2;
            }
        },2,3);

        //计算两个数的乘积
        //动态的改变计算方式
        cellPhone.testWork(new Calculator() {
            @Override
            public double work(double n1, double n2) {
                return n1 * n2;
            }
        }, 2,4);


    }
}

//编写接口
interface Calculator{
    // work方法是完成计算，自己设计
    // 至于该方法完成怎样的计算，交给匿名内部类去完成
    public double work(double n1, double n2);
}

class CellPhone{
    // 定义方法testWork测试计算功能，调用计算接口的work方法。
    //因为接口中work方法有两个参数，所有还要传入两个参数
    // 当我们调用testWork方法时，直接传入一个实现了Calculator接口的匿名内部类即可
    public void testWork(Calculator calculator, double n1, double n2){
        double result = calculator.work(n1, n2);//动态绑定机制
        System.out.println("计算的结果是=" + result);
    }
}

4.局部内部类

内部类
1.编一个类A，在类中定义局部内部类B，B中有一个私有常量name，有一个方法show()打印常量name。进行测试。
2.进阶: A中也定义一个私有的变量name，在show方法中打印测试

package com.yt.homework;

/**
 * @auther yt
 * @address https://www.cnblogs.com/y-tao/
 */
public class Homework05 {
    public static void main(String[] args) {
        A a = new A();
        a.test01();

    }
}

//局部内部类是定义在外部类的局部位置，比如通常在方法中，并且有类名。
class A {
    private String name = "jack";

    public void test01(){
        class B {
            private String name;

            public void setName(String name) {
                this.name = name;
            }

            //外部类名.this表示外部类的一个对象（谁调用就是谁的对象）
            public void show(){
                System.out.println("内部类B " + name + "   外部类A  " + A.this.name);
            }
        }

        B b = new B();//创建内部类对象要在局部内部类后面
        b.setName("tom");
        b.show();

    }

}

5.接口（知识点多）

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

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

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

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

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

1665732328172

package com.yt.homework;

/**
 * @auther yt
 * @address https://www.cnblogs.com/y-tao/
 */
/*
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 person = new Person("唐僧", new Horse());
        person.common();//一般情况下
        person.passRiver();//过河
        person.common();//一般情况下
        person.passRiver();//过河
        person.passRiver();//过河
        person.volcano();//火焰山

    }
}

//交通工具类,是一个接口类
interface Vehicles {
    //接口类的方法默认为抽象类
    public void work();
}

//Horse类，实现接口Vehicles
class Horse implements Vehicles {

    @Override
    public void work() {
        System.out.println("一般情况下，使用小马儿");
    }
}

//Boat类，实现接口Vehicles
class Boat implements Vehicles {
    @Override
    public void work() {
        System.out.println("遇到河流，使用小船船");
    }
}
//扩展程序
class Airplane implements Vehicles {
    @Override
    public void work() {
        System.out.println("使用飞机过火焰山");
    }
}


// 创建交通工具工厂类
class Factory {
    //马儿始终是用一个马儿
    private static Horse horse = new Horse();//单例模式中的饿汉式

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

    //这里将方法做成static,直接使用类调用方法即可
    public static Horse getHorse(){
//        System.out.println("交通工具是 " + horse);
//        return new Horse();
        return horse;
    }

    public static Boat getBoat(){
//        System.out.println("交通工具是 " + boat);
        return new Boat();
    }

    //扩展程序，工厂创建飞机
    public static Airplane getAirplane() {
        return new Airplane();
    }
}

//Person类
class Person {
    private String name;
    private Vehicles vehicles;

    //在创建人对象时，事先给他分配一个交通工具
    public Person(String name, Vehicles vehicles) {
        this.name = name;
        this.vehicles = vehicles;
    }
    //实例化Person对象“唐僧”，要求一般情况下用Horse作为交通工具，遇到大河时用Boat作为交通工具。
    //编程思想：把具体的要求封装成方法
    //思考：在创建对象时，如何不浪费传入的交通工具对象
    public void passRiver() {
        //先得到船
//        Boat boat = Factory.getBoat();
//        boat.work();
        //这个细节很重要
        //判断一下，如果当前vehicles属性是null，就获取小船船
        // 如何防止始终使用的是马 使用instanceOf
//        if (vehicles == null){
        // vehicles instanceof Boat 判断当前的vehicles是不是Boat
        //1.vehicles==null：vehicles instanceof Boat结果为False
        //2.vehicles是一个马儿对象，vehicles instanceof Boat 结果也是False
        //3.vehicles是一个小船儿对象，vehicles instanceof Boat 结果为True
        if (!(vehicles instanceof Boat)){
            vehicles = Factory.getBoat();
        }
        vehicles.work();
    }
    //一般情况下
    public void common(){
        //通过工厂得到马儿
//        Horse horse = Factory.getHorse();
//        horse.work();
        //判断一下，如果当前vehicles属性是null，就获取一匹马儿
//        if (vehicles == null){
        if (!(vehicles instanceof Horse)){
            //使用的是多态
            vehicles = Factory.getHorse();//向上转型
        }
        //体现使用接口来调用
        vehicles.work();//接口的一种解耦的特性

    }

    //扩展程序
    //过火焰山，使用飞机
    public void volcano(){
        //判断是否有其他交通工具
        if (!(vehicles instanceof Airplane)){
            vehicles = Factory.getAirplane();
        }

        vehicles.work();
    }
}

6.成员内部类

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

package com.yt.homework;

/**
 * @auther yt
 * @address https://www.cnblogs.com/y-tao/
 */
public class Homework07 {
    public static void main(String[] args) {
//        new Car().new Air().flow(44);
        //实例化不同的Car对象
        Car car = new Car(20);
        car.getAir().flow();
        Car car1 = new Car(-20);
        car1.getAir().flow();

    }
}
class Car{
    private double temperature;

    public Car(double 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 Air getAir(){
        return new Air();
    }
}

7.枚举类

创建一个Color枚举类
有RED,BLUE,BLACK, YELLOW,GREEN这个五个枚举值/对象
Color有三个属性redValue,greenValue,blueValue
创建构造方法，参数包括这三个属性
每个枚举值都要给这三个属性赋值，三个属性对应的值分别是
red: 255,0,0 ；blue:0,0,255； black:0,0,0； yellow:255,255,0； green:0,255,0；
定义接口，里面有方法show，要求Color实现该接口
show方法中显示三属性的值
将枚举对象在switch语句中匹配使用

package com.yt.homework;

/**
 * @auther yt
 * @address https://www.cnblogs.com/y-tao/
 */
public class Homework08 {
    public static void main(String[] args) {
        //演示枚举值的switch的使用
        Color green = Color.GREEN;
        green.show();

        //switch()中放入枚举对象
        //在每个case后面。直接写上在枚举类中定义的枚举对象即可
        switch(green){
            case READ:
                System.out.println("匹配到红色");
                break;
            case GREEN:
                System.out.println("匹配到绿色");
                break;
            case BLUE:
                System.out.println("匹配到蓝色");
                break;
            case BLACK:
                System.out.println("匹配到黑色");
                break;
            case YELLOW:
                System.out.println("匹配到黄色");
                break;
            default:
                System.out.println("没有匹配到。。。");
        }

    }
}

//枚举类
enum Color implements IColor{
    //枚举
    READ(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;
    //构造器
    Color(int redValue, int greenValue, int blueValue) {
        this.redValue = redValue;
        this.greenValue = greenValue;
        this.blueValue = blueValue;
    }

    //实现接口中的方法
    @Override
    public void show() {
        System.out.println("属性值为" + redValue + "," + greenValue + "," + blueValue);
    }
}
//定义接口
interface IColor{
    public void show();
}

标签：vehicles,静态,void,练习,System,枚举,println,public,out
From： https://www.cnblogs.com/y-tao/p/16794275.html

静态代码，内部类，枚举类练习