javaoop-day03

aAbstract_Animal

package com.oop.aAbstract;

/**
 * 1. 方法不提供花括号，那就必须使用abstract修饰
 * 2. 有抽象方法的类，一定是抽象类，需要使用abstract修饰
 * 3. 子类需要实现抽象父类里所有的抽象方法,或者，子类也声明为抽象类
 * 4. 抽象类就是用来继承的，不能使用final修饰
 * 5. 抽象类里可以没有抽象方法
 * 6. 抽象类不能实例化，因此不能使用new关键字调用构造器，虽然可以提供构造器
 */

public abstract class Animal {
    private String name;
    private int age;
    private String color;

    public Animal(){}
    public Animal(String name, int age, String color ) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public abstract void noise();
}

class Dog extends Animal {
    public void lookHouse() {
        System.out.println("look house");
    }

    public void noise() {
        System.out.println("www");
    }
}

class Cat extends Animal {
    public void catchMouse() {
        System.out.println("catch mouse");
    }
    public void noise() {
        System.out.println("mmm");
    }
}

//如果不想实现抽象类里的抽象方法，该类需要使用abstract修饰
abstract class Duck extends Animal {
    public void swim() {
        System.out.println("swim");
    }

}

aAbstract_AnimalTest

package com.oop.aAbstract;

public class AnimalTest {
    public static void main(String[] args) {
        //直接定义一个Cat类型，调用Cat里的功能
        Cat cat = new Cat();
        cat.noise();
        cat.catchMouse();
        //使用多态的向上造型
        Animal a = new Dog();
        a.noise();

        //下面代码编译错误，因为抽象类不能使用new关键字实例化
        //Animal b = new Animal();
    }
}

bInterface_InterfaceA

package com.oop.bInterface;

/**
 * 概念：
 *     java没有多继承的语法，而有些时候需要使用这种形式，
 *     比如一个类永远两个类的属性或者方法。可以使用另一个知识点来达到这种目的，
 *     就是接口,接口也可以理解为是特殊的抽象类，
 *     也可以理解为是一种规范。
 *   1. 接口的关键字： interface
 *   2. 接口里可以提供成员属性，默认使用public static final修饰，即常量
 *   3. 接口里不能提供构造器，更不能使用new实例化，没有意义。
 *   4. 接口可以提供成员方法，默认使用public abstract修饰，即抽象方法
 */

public interface InterfaceA {
    double PI = 3.14;
    public static final double NUM = 0.618;

    void showInfo();
    public abstract int sum(int a, int b);
}

/**
 *   5. 一个类实现接口，使用关键字implements
 *   6. 实现接口的类，必须实现接口里所有的抽象方法，否则，该类也必须使用abstract关键字修饰
 */
class ClassA implements InterfaceA {
    public void showInfo(){}

    public int sum(int a, int b) {
        return a + b;
    }
}

abstract class ClassB extends ClassA {
    public void showInfo(){}
}

bInterface_InterfaceB

package com.oop.bInterface;

/**
 * 接口与接口之间：
 *   1. 接口可以继承多个接口，使用extends关键字
 *   2. 子接口拥有父接口所有的抽象方法
 *   3. 子接口可以提供自己独有的抽象方法
 *   4. 类实现子接口时，要重写里面所有的抽象方法
 */

public interface InterfaceB {
    void MethodB();
}

interface InterfaceC {
    void MethodC();
}

interface InterfaceD extends InterfaceC, InterfaceB {
    void MethodD();
}

class classT implements InterfaceD {

    @Override
    public void MethodB() {
    }

    @Override
    public void MethodC() {
    }
   @Override
    public void MethodD() {
    }
}

bInterface_InterfaceM

package com.oop.bInterface;

/**
 * 接口与接口之间：
 *   1. 接口可以继承多个接口，使用extends关键字
 *   2. 子接口拥有父接口所有的抽象方法
 *   3. 子接口可以提供自己独有的抽象方法
 *   4. 类实现子接口时，要重写里面所有的抽象方法
 */

public interface InterfaceB {
    void MethodB();
}

interface InterfaceC {
    void MethodC();
}

interface InterfaceD extends InterfaceC, InterfaceB {
    void MethodD();
}

class classT implements InterfaceD {

    @Override
    public void MethodB() {
    }

    @Override
    public void MethodC() {
    }
   @Override
    public void MethodD() {
    }
}

cInterface_InterA

package com.oop.cInterface;

public interface InterA {
    void showInfo();
}
interface InterB {
    void showInfo();
    int calculate(int a, int b);
}

/**
 *  第一种情况：一个子类可以实现多个接口，从而可以达到多继承的效果 ，接口用逗号隔开
 */
class ClassA implements   InterA, InterB {
    @Override
    public void showInfo() {
        System.out.println("ClassA");
    }
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

cInterface_InterATest

package com.oop.cInterface;

public class InterATest {
    public static void main(String[] args) {
        //因为classA是interA和interB的子类型，因此可以向上造型
        InterA x = new ClassA();
        x.showInfo();
        //想要使用x指向对象，调用其里面的计算功能
        //针对于这道题来说，可以向下转型成ClassA，也可以强制转换成InterB
        if(x instanceof ClassA){
            ClassA y = (ClassA)x;
            int result = y.calculate(3, 5);
            System.out.println(result);
        }
        //另一种方式
        if(x instanceof InterB){
            InterB y = (InterB)x;
            int result = y.calculate(3, 5);
            System.out.println(result);
        }
    }
}

cInterface_Program

package com.oop.cInterface;

public class Program {
    public static void main(String[] args) {
        //因为ClassY继承和实现了ClassX，InterM，InterN，可以理解为有多个父亲
        ClassY y = new ClassY();
        y.run();
        y.showInfo();
        y.sum(10, 20);

        //向上造型成不同的父亲变量
        ClassX x = y;
        x.run();
        InterM m = y;
        m.showInfo();
        InterN n = y;
        n.sum(100, 200);
    }
}

interface InterM {
    void showInfo();
}

interface InterN {
    void sum(int a, int b);
}

class ClassX {
    public void run() {
        System.out.println("running");
    }
}

//设计一个子类型，同时具备上面三个引用类型的功能
//第二种方式，一个类可以在继承一个父类的情况下，同时实现多个接口，也可以达到多继承的效果
class ClassY extends ClassX implements InterM, InterN {

    @Override
    public void sum(int a, int b) {
        System.out.println(a + b);
    }

    @Override
    public void showInfo() {
        System.out.println("showInfo");
    }
}

dInterface_Computer

package com.oop.dInterface;

class Computer {
    USB usb1;
    USB usb2;

    public void setUsb1(USB device) {
        this.usb1 = device;
    }
    public void setUsb2(USB device) {
        this.usb2 = device;
    }
}

dInterface_KeyBoard

package com.oop.dInterface;

class KeyBoard implements USB {
    @Override
    public void charge() {
        System.out.println("Keyboard charge");
    }

    @Override
    public String getInfo() {
        return "Keyboard";
    }
}

dInterface_Mouse

package com.oop.dInterface;

class Mouse implements USB {
    @Override
    public void charge() {
        System.out.println("Mouse charge");
    }

    @Override
    public String getInfo() {
        return " Mouse";
    }
}

dInterface_Program

package com.oop.dInterface;

/**
 * 1.USB接口
 * 充电功能 void charge()
 * getInfo()获取信息
 * 2.Computer类型:
 * 属性:
 * 两个USB接口:usb1,usb2
 * 方法:
 * 两个属性的setXXX方法
 * 3.KeyBoard键盘类:
 * 实现USB接口
 * 4. Mouse鼠标类:
 * 实现USB接口
 * 5.Program测试类:
 * 创建一个电脑对象
 * 创建一个键盘对象
 * 创建一个鼠标对象
 * 将键盘和鼠标插入到电脑中
 */

public class Program {
    public static void main(String[] args) {
        // 创建一个电脑对象
        Computer computer = new Computer();
        // 创建一个键盘对象
        KeyBoard keyBoard = new KeyBoard();
        // 创建一个鼠标对象
        Mouse mouse = new Mouse();
        // 将键盘和鼠标插入到电脑中
        computer.setUsb1(keyBoard);
        computer.setUsb2(mouse);

        // 测试充电和获取信息功能
        keyBoard.charge();
        System.out.println(keyBoard.getInfo());
        mouse.charge();
        System.out.println(mouse.getInfo());
    }
}

dInterface_USB

package com.oop.dInterface;

interface USB {
    void charge();

    String getInfo();
}

eInterface_Person

package com.oop.eInterface;

public class Person implements Comparable<Person> {
    private String name;
    private int age;
    private int height;
    private int weight;

    public Person(String name, int age, int height, int weight) {
        this.name = name;
        this.age = age;
        this.height = height;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", height=" + height +
                ", weight=" + weight +
                '}';
    }

    /**
     * 如果想要进行比较，除了要实现comparable接口外，还要实现里面的比较方法compareTo
     *
     * @param o the object to be compared.
     * @return 升序： this的相关属性-传入的o的相关属性
     * 降序： 传入的o的相关属性-this的相关属性
     */
    @Override
    public int compareTo(Person o) {
        //按照年龄比较，升序：  若返回负数，证明this小，返回0证明一样，返回正数this大
        //return this.age - o.age;

        //按照身高降序：
        //return o.height - this.height;

        //先按照年龄升序，如果年龄相同，按照身高降序
        int r = this.age - o.age;
        if (r == 0) {
            r = o.height - this.height;
        }
        return r;
    }
}

eInterface_PersonTest

package com.oop.eInterface;

import java.util.Arrays;
import java.util.Comparator;

public class PersonTest {
    public static void main(String[] args) {
        Person[] ps = new Person[3];
        ps[0] = new Person("张三", 28, 170, 80);
        ps[1] = new Person("李四", 50, 180, 78);
        ps[2] = new Person("王五", 20, 176, 99);

        Arrays.sort(ps);
        System.out.println(Arrays.toString(ps));

        //修改比较规则，按照体重进行升序，不修改源代码，因为Person类可能正在使用。
        //此时就可以使用Comparator比较器重新自定义比较规则
        //使用匿名内部类常遭一个比较器对象
        Comparator c1 = new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getWeight() - p2.getWeight();
            }
        };
        //数组工具类sort方法，重载了很多方法，包含一个sort(0bject[]a,Comparator c);
        Arrays.sort(ps, c1);
        System.out.println(Arrays.toString(ps));
    }
}

fEnum_Season

package com.oop.fEnum;

/**
 * 使用自定义的方式，来组织一个季节性的枚举类型
 * 1. 提供一堆可以向外界暴露的该类型的对象
 * 2. 构造器私有化、
 * 3. 可以提供属性，来描述对象信息
 * 4. 给属性提供getXXX方法，向外界暴露，不要提供setXXX方法，因为只读
 */

public class Season {
    public static final Season SPRING = new Season("春天", "春暖花开");
    public static final Season SUMMER = new Season("夏天", "夏至秋至");
    public static final Season AUTUMN = new Season("秋天", "秋高气爽");
    public static final Season WINTER = new Season("冬天", "冬至春至");

    private final String name;
    private final String desc;

    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }


    public String getDesc() {
        return desc;
    }

    @Override
    public String toString() {
        return "这是一个季节";
    }
}

fEnum_SeasonTest

package com.oop.fEnum;

import com.oop.eInterface.Person;

import java.util.Arrays;
import java.util.Comparator;

public class SeasonTest {
    public static void main(String[] args) {
        Season S = Season.AUTUMN;
        //直接输出
        System.out.println(S);
        //打印这个季节的名字
        System.out.println(S.getName());

        //获取描述信息
        System.out.println(S.getDesc());

    }
}

gEnum_Direction

package com.oop.gEnmu;

/**
 * 方向枚举：前后左右
 */

public enum Direction implements InterA {
    BEFORE("前") {
        @Override
        public void showInfo() {
            System.out.println("前进");
        }
    },
    AFTER("后") {
        @Override
        public void showInfo() {
            System.out.println("后退");
        }
    },
    LEFT("左") {
        @Override
        public void showInfo() {
            System.out.println("向左");
        }
    },
    RIGHT("右") {
        @Override
        public void showInfo() {
            System.out.println("向右");
        }
    };

    private String name;
    private Direction(String name) {
        this.name = name;
    }

    public void showInfo() {
        System.out.println("方向");
    }

    public static void main(String[] args) {
        Direction direction = Direction.BEFORE;
        System.out.println(direction);
        direction.showInfo();
    }


}

interface InterA {
    void showInfo();
}

gEnum_Season

package com.oop.gEnmu;

import javafx.scene.effect.ImageInput;

import javax.imageio.stream.ImageInputStream;

/**
 * 使用构造器，获取一堆枚举对象。
 * 1. 枚举类里的第一行，必须是枚举的对象
 * 2. 如果提供构造器，构造器必须私有化，枚举对象必须显式调用构造器
 * 3. 可以提供属性，必须私有化
 *
 * 4. 自定义的枚举，默认继承了java.long.Enum抽象类，
 */

public enum Season {
    SPRING("春天", "春暖花开"),
    SUMMER("夏天", "夏至秋至"),
    AUTUMN("秋天", "秋高气爽"),
    WINTER("冬天", "冬至春至");

    private String name;
    private String desc;


    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;


    }
}

gEnum_Week

package com.oop.gEnmu;

/**
 * 案例一： 简单定义一个枚举
 * 注意：
 * 1. 第一行，必须是枚举类的对象  名称自定义，应该符合常量的命名规则
 * 2. 内部系统提供一个无参构造器，因为创建枚举对象时，调用的是无参构造器，
 * 因此，对象后面的小括号是可以省略的。
 * 注意： 构造器是私有的。
 * 3.
 */

public enum Week {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
//    private Week(){}

    public static void main(String[] args) {
        System.out.println(Week.FRIDAY);
    }
}

hInnerClass_aMember_Outer

package com.oop.hInnerClass.aMember;

import sun.java2d.pipe.OutlineTextRenderer;

/**
 * 成员内部类:
 * 1.定义在一个类的里面，与类的其他成员是平级关系。没有static修饰
 * 2.该内部类的访问权限可以是private，默认的，protected,public
 */

public class Outer {
    private String name;
    private int age;

    public Outer(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void showInfo() {
        System.out.println(name + "," + age);
    }

    //定义一个成员内部类
    class Inner {
        private String name;
        private int age;

        public Inner(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public void showInfo() {
            System.out.println(name + "," + age);
            //访问外部类的成员：类名，this，成员
            System.out.println(Outer.this.name + "," + Outer.this.age);
        }
    }

    public static void main(String[] args) {
        // 先创建一个外部类
        Outer outer = new Outer("张三", 20);
        //通过外部类对象，来实例化一个内部类对象
        Outer inner = new Outer("李四", 30);
        inner.showInfo();
    }

}

hInnerClass_bStatic_Outer

package com.oop.hInnerClass.bStatic;

/**
 * 定义在一个类的内部，与这个类的成员（属性、方法）平级，并且使用static修饰的类。
 * 1、访问权限可以是任意的权限，类似于一个类中的成员。
 * 2、实例化的过程中，直接使用 new实例化一个外部类 .内部类对象即可。
 * 3、内部类编译后，也会生成.class字节码文件。格式：外部类$内部类 .class
 */

public class Outer {
    private String name;

    public Outer(String name) {
        this.name = name;
    }

    public void showInfo() {
        System.out.println(name);
    }

    static class Inner {
        private String name;

        public Inner(String name) {
            this.name = name;
        }

        public void showInfo() {
            System.out.println(name);
            //不能直接访问外部类的成员
            // System.out.println(Outer.this.name);
        }
    }

    public static void main(String[] args) {
        //创建内部类的对象： new 外部类名，内部类构造器
        Inner i = new Inner("erzi");
    }
}

hInnerClass_cPart_Outer

package com.oop.hInnerClass.cPart;

/**
 * 局部内部类：
 * 在方法中定义的内部类，和局部变量的用法一样，出了作用域就失效了。
 */

public class Outer {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a);

        class Inner {
            private String name;

            public Inner(String name) {
                this.name = name;
            }

            public String getName() {
                return name;
            }

        }
        Inner inner = new Inner("小明");
        System.out.println(inner.getName());
    }
}

hInnerClass_dAnonymous_Outer

package com.oop.hInnerClass.dAnonymous;

/**
 * 匿名内部类：
 *     就是没有名字的子类型对象
 *
 *     接口名|抽象类名|父类名 变量 =  new 接口名|抽象类名|父类名(){
 *         方法的重写
 *     };
 */
public class Outer {
    public static void main(String[] args) {
        A a = new A(){
            //匿名内部类，提供成员属性
            private String name = "--你好，欢迎来到中国--";
            //重写接口A里的抽象方法
            public void showInfo(){
                System.out.println(name);
            }
            //子类提供了独有的getXXX方法
            public String getName(){
                return name;
            }
        };
        // 编译期间，看变量类型，因此能调用到showInfo. 运行期间看对象类型
        a.showInfo();
        //a.getName();  //编译期间，a里根本没有getName方法，编译都不会通过的
    }
}
interface A{
    public void showInfo();
}
//class B implements A{
//    public void showInfo() {}
//}

zexercise_execise01

package com.oop.hInnerClass.cPart;

/**
 * 局部内部类：
 * 在方法中定义的内部类，和局部变量的用法一样，出了作用域就失效了。
 */

public class Outer {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a);

        class Inner {
            private String name;

            public Inner(String name) {
                this.name = name;
            }

            public String getName() {
                return name;
            }

        }
        Inner inner = new Inner("小明");
        System.out.println(inner.getName());
    }
}

zexercise_execise02

package com.oop.zexercise;
/*
    2. 设计⼀个交通⼯具抽象类，提供抽象⽅法--驾驶
    汽⻋作为交通⼯具的⼀种，实现了驾驶的⽅法(在⻢路上驾驶) ⽕⻋作为交通⼯具的⼀种，实现了驾
    驶的⽅法(在铁路上驾驶) ⻜机作为交通⼯具的⼀种，实现了驾驶的⽅法(在天上驾驶)
    需求：做⼀个测试类，在测试类的main函数中，分别实例化⼀个汽⻋的对象，
    ⽕⻋的对象和⻜机的对象，并分别描述驾驶⾏为
 */

public class exercise02 {
    public static void main(String[] args) {
        Car car = new Car();
        car.active();

        Plane plane = new Plane();
        plane.active();

        Train train = new Train();
        train.active();

    }
}

abstract class Drive {
    public abstract void active();
}

class Train extends Drive {
    public void active() {
        System.out.println("--在铁路上驾驶--");
    }
}

class Car extends Drive {
    public void active() {
        System.out.println("--在马路上驾驶--");
    }
}

class Plane extends Drive {
    public void active() {
        System.out.println("--在天上驾驶--");
    }
}

zexercise_execise03

package com.oop.zexercise;
/*
    3. 设计⼀个家政服务规范(接⼝): 洗⾐服, 扫地, 买菜, 做饭 设计⼀个保姆类, 保姆需要遵循这些规范
    需求：在测试类中，实例化⼀个保姆的对象，然后让保姆买菜，做饭，扫地
 */

public class exercise03 {
}
interface HouseKeeping {

}

class  BaoMu implements HouseKeeping {

}

class Wash implements HouseKeeping {

}

class Scan implements HouseKeeping {

}

class Buy implements HouseKeeping {

}

class Cook implements HouseKeeping {

}

zexercise_execise04

package com.oop.zexercise;
/*
    设计⼀个动物类，属性: 姓名，性别 设计⼀个猫类，设计⼀个狗类， 猫和狗都继承⾃动物类
    需求：在测试类中设计⼀个⽅法，这个⽅法需要⼀个参数，参数的类型可以是猫类，也可以是狗类 -
     >多态(动物类 )  在⽅法体内，将传⼊的猫或者狗的属性输出即可 输出到底是猫还是狗
 */

public class exercise04 {
}

zexercise_execise05

package com.oop.zexercise;
/*
    5. 设计⼀个数据传输接⼝：Type-C标准 设计⼀个防⽔的接⼝：防⽔ 设计⼀个⼿机类，
       实现这个数据传输接⼝，采⽤Type-C；同时实现了防⽔的接口
 */

public class exercise05 {
}