面向对象19：作业

1. List item

---

package com.homework;

/**
 * @version 1.0
 * @anther 田毅
 */
public class Objecthomework2 {
    public static void main(String[] args) {
        Animal cat = new Cat();
        Animal dog = new Dog();
        cat.shout();
        dog.shout();
    }
}
abstract class Animal{
   public abstract void  shout();
}
class Cat extends Animal {

    @Override
    public void shout() {
        System.out.println("miaomiao");
    }
}
class Dog extends Animal{
    @Override
    public void shout() {
        System.out.println("wangwang");
    }
}

---

匿名内部类也可以虚拟实例化抽象类对象并作为参数传递

package com.homework;

/**
 * @version 1.0
 * @anther 田毅
 */
public class Objecthomework {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();
        //解读
        //1、匿名内部类是
//        new Icalculate() {
//            @Override
//            public double work(double n1, double n2) {
//                return n1+n2;
//            }
//        }, 同时也是一个对象
        // 他的编译类型是Icalculate，他的运行类型就是匿名内部类
        cellphone.testWork(new Icalculate() {
            @Override
            public double work(double n1, double n2) {
                return n1+n2;
            }
        },10,8);//匿名内部类会传给testWork的icalculate

        cellphone.testWork(new Icalculate() {
            @Override
            public double work(double n1, double n2) {
                return n1 * n2;
            }
        },10,8);
    }
}
interface Icalculate{
    //work方法 是完成计算，但是题没有具体要求，所以自己设计
    //至于该方法怎么样完成的计算，交给匿名内部类来完成。
    public double work(double n1,double n2);
}
class Cellphone{
    //解读，当我们调用testWork方法时，直接传入一个实现了Icalculate接口的匿名内部类即可
    //该匿名内部类，可以灵活的实现work方法，可以灵活的实现work，完成不同的计算任务
    public void testWork(Icalculate icalculate,double n1,double n2){ //行参就实现了接口，所以不用implement
        double  result = icalculate.work(n1,n2);//动态绑定
        System.out.println("计算后的结果是=" + result);
    }
}

---

package com.homework;

import org.w3c.dom.ls.LSOutput;

/**
 * @version 1.0
 * @anther 田毅
 */
public class Objecthomework3 {
    public static void main(String[] args) {
        new A().f1();
    }
}
class A {

    private String name = "tianyi1";
    public void f1(){

        class B{ //局部内部类
        private final String  name = "tianyi";
        public void show(){
            //如果内部类和外部类的属性重名，可以通过 外部类.this.属性名 来指定
//            System.out.println("NAME=" + NAME + "外部类name=" + name);
            System.out.println("NAME=" + name + "外部类name=" + A.this.name);
        }
    }
        B b = new B();
        b.show();
    }
}

---

/*
1,有一个交通工具接口类 venicLes，有Work接口
2，有 Horse类和Boat类分别实现 Vehicles
3。创建交通工具工厂类，有两个方法分别获得交通工具 Horse和Boat ，全程只能用同一匹马，且不能浪费初始交通工具
4。有 Person类，有name和 Vehicles属性，在构造器中为两个属性赋值
5。实例化 Person。对象“唐僧”，要求一般情况下用 Horse作为交通工具，遇到大河时用Boat作为交通工具 使用代码实现上面的要求
6、如果唐僧过火焰山，使用 飞机====>扩展性
编程需求—>理解—>代玛
*/

工厂类

package com.homework;

/**
 * @version 1.0
 * @anther 田毅
 */
public class VehiclesFactory {

    //马始终是同一匹马
    private static Horse horse = new Horse();//饿汉式

    private VehiclesFactory(){//为了不然去创建该类的对象

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

     //这里将方法做成static比较方便，没有必要去创建对象
    public static Horse getHorse() {
//        return new Horse();
        return horse;
    }
    public  static Boat getBoat() {
        return new Boat();
    }
    public static Plane getPlane() {
        return new Plane();
    }
}

---

船类

package com.homework;

/**
 * @version 1.0
 * @anther 田毅
 */
public class Boat implements Vehicles{
    @Override
    public void work() {
        System.out.println("throught river use boat");
    }
}

---

马类

package com.homework;

/**
 * @version 1.0
 * @anther 田毅
 */
public  class Horse implements Vehicles {
    @Override
    public void work() {
        System.out.println("normal use horse");
    }
}

飞机类

package com.homework;

/**
 * @version 1.0
 * @anther 田毅
 */
public class Plane implements Vehicles{

    @Override
    public void work() {
        System.out.println("fir mountion");
    }
}

---

人类

package com.homework;

/**
 * @version 1.0
 * @anther 田毅
 */
public class Person {
//    4。有 Person类，有name和 Vehicles属性，在构造器中为两个属性赋值
    private String name;
    private Vehicles vehicles;
    //在创建人对象时，事先给他传一个交通工具
    public Person(String 唐僧, Horse horse) {
        this.name = name;
        this.vehicles = vehicles;
    }
    //实例化 Person。对象“唐僧”，要求一般情况下用 Horse作为交通工具，遇到大河时用Boat作为交通工具
    //这里涉及到一个编程思路，就是可以把具体的要求，封装成方法--> 编程思想
    //如何不浪费在构建对象时传入的交通工具
    public void passRiver(){
        //先得到船
//        判断一下，当前的 vehicles属性是nulL，就获取一艘船
//        Vehicles boat = VehiclesFactory.getBoat();
//        boat.work();
        //如何防止始终使用的是传入的马  instanceof
//        if (vehicles == null){
        //vehicles instanceof Boat 判断当前的vhicles是不是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 = VehiclesFactory.getBoat();
        }
        vehicles.work();
    }
    public void passRoad(){
        //先得到马
        //判断一下，当前的 vehicles属性是否已经存在了
        /*
        if (vehicles == null){
            //这里使用的是多态，和向上转型的特点
            vehicles = VehiclesFactory.getHorse();
        }

         */
        if (!(vehicles instanceof Horse)){
            vehicles = VehiclesFactory.getHorse();
        }
        vehicles.work();
    }

        //格式化快捷键  option+command+L
    public void passfir() {
        if (!(vehicles instanceof Plane)) {
            vehicles = VehiclesFactory.getPlane();
        }
        vehicles.work();
    }
}

---

交通工具接口

package com.homework;

/**
 * @version 1.0
 * @anther 田毅
 */
public interface Vehicles {

    //1,有一个交通工具接口类 venicLes，有Work接口
    public void work();
}

---

main

package com.homework;

/**
 * @version 1.0
 * @anther 田毅
 */
public class Objecthomework6 {
    public static void main(String[] args) {
        Person tang = new Person("唐僧", new Horse());
        tang.passRiver();
        tang.passRoad();

    }
}
/*
1,有一个交通工具接口类 venicLes，有Work接口
2，有 Horse类和Boat类分别实现 Vehicles
3。创建交通工具工厂类，有两个方法分别获得交通工具 Horse和Boat  ，全程只能用同一匹马，且不能浪费初始交通工具
4。有 Person类，有name和 Vehicles属性，在构造器中为两个属性赋值
5。实例化 Person。对象“唐僧”，要求一般情况下用 Horse作为交通工具，遇到大河时用Boat作为交通工具 使用代码实现上面的要求
6、如果唐僧过火焰山，使用 飞机====>扩展性
编程需求--->理解--->代玛
 */

---

package com.homework;

/**
 * @version 1.0
 * @anther 田毅
 */
public class Objecthomework7 {
    public static void main(String[] args) {
        Car_ car_ = new Car_(60);
        car_.getAir().flow();
        Car_ car2_ = new Car_(-1);
        car2_. getAir().flow();
        Car_ car22_ = new Car_(20);
        car22_. 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("温度大于40度空调吹冷气");
            } else if (temperature < 0) {
                System.out.println("温度小于0度空调吹暖气");
            }else {
                System.out.println("温度正常，关闭空调");
            }
        }
    }
    public Air getAir(){
        return new Air();
    }
}

---

package com.homework;

/**
 * @version 1.0
 * @anther 田毅
 */
public class Objecthomework8 {
    public static void main(String[] args) {
        //演示一下枚举值得 switch使用
        Color green = Color.YELLOW;
        green.show();
//比较一下
// switch()中，放入枚举对象
//在每个case后，直接写上在枚举类中，定义的枚举对象即可
        switch (green){
            case YELLOW:
                System.out.println("huang");
                break;
            case BLACK:
                System.out.println("hei");
            case GREEN:
                System.out.println("lv");
            case RED:
                System.out.println("hong");
            case BLUE:
                System.out.println("blue");
            default:
                System.out.println("no match");
        }

    }
}
enum Color implements color_{
    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;

    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 color_{
    public void show();
}