java学习笔记(3) - 面向对象(3)

1. 接口

package chapter03;

// 外部类 只能使用 public 或者 默认(default)/什么都不写
public class oop1 {
    public static void main(String[] args){

        // 接口
        Computer c = new Computer();// 实例化电脑
        Light light = new Light(); // 实例化电灯1
        c.usb1 = light;// 电脑接口1接入电灯1
        Light light1 = new Light();// 实例化电灯2
        c.usb2 = light1;// 电脑接口1接入电灯1
        c.powerSupply();// 成功输出 "电脑提供电源"
        System.out.println(c.name); // 输出"电脑",类继承接口中的属性

        // 解决子类继承单一父类的情况
        Duck duck = new Duck();
        duck.fly();// "能飞了!"
        duck.swim();// "能游泳了!"
    }
}

// 接口(interface) - 可以对比抽象类(简单的认为接口就是一个数据类型)
// 它是指定一种类型的规范,基本语法: interface 接口名称{接口规范,限制属性和方法等}
// 接口其实是抽象的
// 规则的属性必须为固定值，而且不能修改。
// 属性和行为的访问权限必须为公共的。
// 属性应该是静态的
// 行为应该是抽象的
// 接口和类是两个层面的东西
// 接口可以继承其他接口
// 类的对象需要遵循接口，在java中，这个遵循，称之为实现(implements)，类需要实现接口,而且可以实现多个接口
/*
* 为什么需要 接口 : 我们都知道,java中,类的继承只能有一个,也就是说,一个子类只能有一个父类,但是这样就导致了一个
* 问题,比如说你现在设置一个 鸟的class 有的鸟能飞,有的鸟能游泳,有的鸟又能飞又能游泳,这就导致了一个问题,有的鸟能
* 飞但是不会游泳(麻雀),有的鸟会游泳但是不能飞(企鹅),有的鸟技能飞又能游泳(鸭子),这就引出了接口,因为一个类可以继承
* 多个接口
* */

// 例子1. 一个类继承多个接口解决单一父类的情况
interface Flyable{ // 飞接口
    // 设置接口方法需要使用 default 关键字
    default void fly(){
        System.out.println("能飞了!");
    }
}

interface Swimmable{ // 游泳接口
    // 设置接口方法需要使用 default 关键字
    default void swim(){
        System.out.println("能游泳了!");
    }
}

// 创建又能游泳又能飞的鸭子类
class Duck implements Flyable,Swimmable{}

// 例子2. 接口继承以及对应方法复写
interface USBInterface {
    String name = "电脑";
}

// 接口继承另一个接口
interface USBSupply extends USBInterface {
    void powerSupply(); // 方法修饰符必须要使用public来修饰
}
interface USBReceive extends USBInterface {
    void powerReceive();
}

// 类使用接口需要 implements 关键字
class Computer implements USBSupply {

    // 接口定义变量
    public USBReceive usb1;
    public USBReceive usb2;

    // 必须重写继承的接口的方法(重写方法的关键字必须大于等于设置的关键字)
    public void powerSupply() { // 这里是 public ,设置的是 default(默认)
        System.out.println("电脑提供能源");
        usb1.powerReceive(); // 成功输出 "电灯接收能源"
        usb2.powerReceive(); // 成功输出 "电灯接收能源"
    }
}
class Light implements USBReceive {
    public void powerReceive() {
        System.out.println("电灯接收能源");
    }
}

// 接口之间还可以多继承
interface  AA{
    void method1();

}
interface  BB{
    void method2();

}
interface CC extends AA,BB{

}

2. 枚举

• 官方文档

package chapter03;

// 外部类 只能使用 public 或者 默认(default)/什么都不写
public class oop1 {
    public static void main(String[] args){
        
        // 枚举
        System.out.println(City.BEIJING.name); // "北京"
        System.out.println(City.SHANGHAI.code);// "1102"
        
        // 自己手写的枚举实现
        System.out.println(MyCity.SHANGHAI.name);// "上海"
        System.out.println(MyCity.BEIJING.code);// "1101"
    }
}

// 枚举 - enum
// 枚举是一个特殊的类，其中包含了一组特定的对象，这些对象不会发生改变, 一般都使用大写的标识符，
// 枚举使用enum关键字使用
// 枚举类会将对象放置在最前面，那么和后面的语法需要使用分号隔开
// 枚举类不能创建对象，它的对象是在内部自行创建

/*
* 创建一个枚举类型,里面有默认的 BEIJING 和 SHANGHAI 属性,这两个属性也是一个对象
* 可以通过 自定义构造方法 设置对应的属性对象(BEIJING,SHANGHAI)
* */
enum City {
    BEIJING("北京", 1001),
    SHANGHAI("上海", 1002);

    // 自定义构造方法
    City( String name, int code ) {
        this.code = code;
        this.name = name;
    }
    public String name; // 属性对象中默认有 name 属性
    public int code; // 属性对象中默认有 code 属性
}

// 实现原理(自己手写)
class MyCity {
    public String name;
    public int code;

    private MyCity(String name, int code) {
        this.code = code;
        this.name = name;
    }

    // 在内部自动创建对象(实例化自身)
    public static final MyCity BEIJING = new MyCity("北京", 1001);
    public static final MyCity SHANGHAI = new MyCity("上海", 1002);
}
// 枚举还有许多方法需要自己寻找

3. 匿名类

package chapter03;

// 外部类 只能使用 public 或者 默认(default)/什么都不写
public class oop1 {
    public static void main(String[] args){

                    // 匿名类的使用场景
            /*
            * 匿名类实际上是一个继承了抽象类并实现了抽象方法的子类,当你使用匿名类来实例化抽象类时，
            * 你实际上是在创建一个继承了抽象类并提供了具体实现子类对象。这也就解释了为什么抽象类
            * 能够直接new,这也可以直接套用到下面的接口中去
            * */
            Me me = new Me();
            // 我们不关心谁能打招呼,,我们关系的是每一个人都能打招呼,也就是传入名字就能输出谁打招呼
            me.sayHello( new Person24() {// 实例化抽象类(前提是我们必须补充完整中定义好的方法)
                // 补充完整抽象类中的抽象方法就能new实例化抽象类
                public String name() {
                    return "wangwu";
                }
            });

            me.sayHello( new Person24() {
                public String name() {
                    return "zhaoliu";
                }
            });
        
        // 匿名类实例化类
        new Bird24().fly(); // 成功输出"使用翅膀飞翔"

        // 匿名类实例化接口
        new Fly(){ // 实例化接口(前提是我们必须补充完整中定义好的方法)
            public void fly() {
                System.out.println("使用飞行器飞翔");
            }
        }.fly(); // 成功输出"使用飞行器飞翔!"
    }
}

// 匿名类
// 在某些场合下，类的名字不重要，我们指向使用类中的方法或功能。那么此时我们可以采用特殊的语法：匿名类
// 所谓的匿名类，就是没有名字的类

/*
* 好比我们现在要求实现一个抽象类为人,里面有一个抽象方法,返回人的名字(我们在new后补全)
* */
interface Fly {
    void fly(); // 抽象方法
}
class Bird24 implements Fly {
    public void fly() {
        System.out.println("使用翅膀飞翔");
    }
}

// 抽象类
abstract class Person24 {
    // 抽象方法
    public abstract String name();
}

// 打招呼的类
class Me {
    public void sayHello(Person24 person24) {
        System.out.println("Hello " + person24.name());
    }
}

// 常规的方法,每一个人都需要设置成一个类
class Zhangsan extends Person24 {
    public String name() {
        return "zhangsan";
    }
}
class Lisi extends Person24 {
    public String name() {
        return "lisi";
    }
}

4. java中的bean规范

package chapter03;

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

        // TODO 面向对象
        // 1. 主要用于编写逻辑
        // 2. 主要用于建立数据模型(Bean)
        // TODO Bean类得设计规范：Bean规范
        // 1. 类要求必须含有无参，公共得构造方法
        // 2. 属性必须私有化，然后提供公共得，set，get方法
        User25 user = new User25(); // 实例化一个对象
        user.setAccount("admin"); // 设置对象中的账号属性
        user.setPassword("admin") ;// 设置对象中的密码属性
        System.out.println(login(user));// 调用登陆方法
    }
    // 设置登陆方法(传入要登陆的用户是谁)
    public static boolean login( User25 user ) {
        if ( user.getAccount().equals("admin") && user.getPassword().equals("admin") ) {
            return true;
        } else {
            return false;
        }
    }
}

// 设置一个类
class User25 {
    // 类的属性必须私有化,不能随便被外界所读取
    private String account;
    private String password;

    // 设置修改类中属性的方法
    public void setAccount( String account ) {
        this.account = account;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    // 设置读取类中属性的方法
    public String getAccount() {
        return account;
    }
    public String getPassword() {
        return account;
    }
}