面向对象设计（下）《Ⅱ》

抽象类

抽象类可以不包含抽象方法

抽象类的理解（抽象类不能实例化）

①为什么使用抽象类：
某种情况下，我们只知道父类的子类有一些方法，但是不知道子类的方法具体怎么实现的
这时，Java允许父类只提供一个方法的声明，而不提供具体的实现
提供的方法声明为抽象方法；含有一个或者多个抽象方法的类称之为抽象类
②抽象类的声明
访问控制修饰符（public private） abstract class 类名{}
③抽象方法的声明
访问控制修饰符 abstract 返回类型 方法名（参数列表）; 注意，没有{}因为其没有具体实现的代码块，所以 以 ; 结尾 即可
④抽象类中可以有构造器：作用：子类继承父类所有属性，需要知道父类的属性是如何初始化的
⑤子类继承父类时，如果重写的父类所有的抽象方法，那么该类就为具体类，子类就可以实例化；
如果子类没有重写父类中所有的抽象方法，那么该子类仍为抽象类

public class abstructClass {
    public static void main(String[] args) {
        Chinese c1=new Chinese(18,"中国","坚强");
        c1.show();
    }
}
abstract class person{
    private int age;
    private String nation;

    public person() {
    }

    public person(int age, String nation) {
        this.age = age;
        this.nation = nation;
    }
    public abstract void show();
}
class Chinese extends person{
    private String spirit;

    public Chinese() {
    }

    public Chinese(int age, String nation, String spirit) {
        super(age, nation);
        this.spirit = spirit;
    }
    public void show(){
        System.out.println("中国人的精神为"+this.spirit);//对方法进行了重写，所以其类为具体类，可以实例化了
    }
    
}
abstract class American extends person{
    private String nation;

    public American() {
    }

    public American(int age, String nation, String nation1) {
        super(age, nation);
        this.nation = nation1;
    }
    public abstract void show();//这里没有对方法进行重写，所以其还为抽象类
}

设计模式

模板方法设计模式

抽象类体现的就是一种模板设计模式，父类作为子类的模板
解决的问题：当解决的问题一部分是确定的，一部分是不确定的，这时就可以把不确定的方法暴露出去，交给子类去实现 ； 编写一个抽象父类，父类中写一个或者多个通用方法，交给子类去实现，就是一种设计模式

代理模式

所谓代理模式就是两个类实现同一个方法，其中一个A类作为属性存于B类中，B
类就作为A类的代理类，其构造器中创建A类对象，抽象方法的实现里采用A类方法对于接口方法的实现
下面举例：A类方法

public class specifyboss implements boss{
    @Override
    public void consume() {
        System.out.println("秘书的老板消费");
    }

    @Override
    public void meet() {
        System.out.println("秘书的老板见面");
    }
}

B类方法

public class specifybosspoxey implements boss{
   private specifyboss smallboss;//秘书为老板服务，所以属性中由老板

    public specifybosspoxey() {
        smallboss=new specifyboss();//调用秘书是为了联系老板，所以构造器中创建老板对象；
    }

    @Override
    public void consume() {
        smallboss.consume();//秘书也实现接口，但是实现抽象方法时用自己老板中写的方法；
    }

    @Override
    public void meet() {
        smallboss.meet();
    }
}

最终的测试：

工厂方法设计模式

接口

优点：解决了Java中的单继承的局限性，可以定义多个不相关事物的相同功能

接口的定义（接口仅可以用public修饰）

①接口和类是平级的，即定义时为 访问控制修饰符（public private） interface 接口名
②接口可以理解为特殊的抽象类 其内只可以有 全局静态常量 和 抽象方法，即只可以包含
public static final 数据类型 数据名=初始值 （系统默认会加上static final）
public abstract 返回值类型 方法名(参数列表);（系统默认加上abstract）
③接口中不可以有 变量 代码块 构造器
③接口不可以被创建，只可以被实现

接口的实现

①实现接口的类为“实现类”，实现类的功能和“继承是相同的”，实现类可以实现接口中的所有抽象方法
②实现类实现了接口中的所有抽象方法，其就为具体类，可以创建对象实例化，否则不可以实例化
③接口可以多个实现，即一个实现类可以实现多个接口
④接口不能继承任何类，但是接口可以继承接口，并且可以多继承接口、
⑤一个类可以继承另一个类，同时实现多个接口
（先继承后实现）
⑥接口也支持多态，即接口引用指向实现类对象

public class interfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyer.number);//验证number为静态常量 以及number为final类型，不可以被修改
        birds b1=new birds();
        b1.shoutime();
        b1.show();
        b1.talent();
    }
}
interface Flyer{
    public static final int number=100;
    public abstract void shoutime();
}
interface Runner{
    public  abstract void show();
}
class Animal{
    public void talent(){
        System.out.println("吃饭");
    }
}
class birds extends Animal implements Flyer,Runner{//一个类可以实现多个接口
    @Override
    public void shoutime() {
        System.out.println("鸟儿会飞");
    }
    public void show(){
        System.out.println("鸟儿可以跑");
    }
}
class plane implements Flyer{
    @Override
    public void shoutime() {
        System.out.println("飞机也会飞");
    }
}

jdk1.8中接口的默认方法和静态方法

Ⅰ jdk1.8中的接口中可以声明默认方法
①默认“类优先”，当类中继承的父类和实现接口的默认方法同名时，默认“类优先”，即执行继承父类中的方法
②当实现多个接口的默认方法时，实现类中要声明出来具体实现哪个接口的方法—具体步骤：接口名.super.默认方法名
Ⅱ jdk1.8中的接口可以声明静态方法

public class interface_jdk{
    public static void main(String[] args) {
        myinterface my=new myinterface();
        my.show();
        jdkinterface.add();
    }

}
//jdk1.8中的接口中可以声明默认方法
//①默认“类优先”，当类中继承的父类和实现接口的默认方法同名时，默认“类优先”，即执行继承父类中的方法
//②当实现多个接口的默认方法时，实现类中要声明出来具体实现哪个接口的方法----具体步骤：接口名.super.默认方法名
//jdk1.8中的接口可以声明静态方法
interface jdkinterface{
    default void show(){
        System.out.println("这是接口中的默认方法的声明");
    }
    public static void add(){
        System.out.println(10+20);
    }
}
class superinterface{
    public void show(){
        System.out.println("这是父类中的方法");
    }
}
class myinterface extends superinterface implements jdkinterface{
    @Override
    public void show() {
        super.show();
    }
}

内部类

成员内部类

静态成员内部类的创建

格式：创建内部静态类的格式 类.静态内部类 引用名=new 类.静态内部类

 //创建静态内部类对象
      parent.children ch=new parent.children();//这是一个创建内部静态类的格式 类.静态内部类 引用名=new 类.静态内部类
      ch.setName("李华");
      ch.setAge(18);
      ch.setHobby("basketball");
        System.out.println(ch.toString());

非静态成员内部类的创建

格式：类.非静态内部类 引用名=类引用.new 非静态内部类

//创建非静态内部类的对象
        parent p=new parent();
        parent.dog d=p.new dog();//这是一个语法格式，记住即可 类.非静态内部类 引用名=类引用.new 非静态内部类

内部类可以运用其类中的属性

class parent{
    private String name="小王";
    private int age;
    private String owner="my";
    public class dog{
        private String name="白白";
        private int age;
        public void setName(String name) {
            System.out.println("内部类可以运用外部类的属性"+owner);
            System.out.println("局部变量中的name:"+name);
            System.out.println("内部类中的name："+this.name);
            System.out.println("外部类中的name"+parent.this.name);
            this.name = name;
        }

测试如下：

局部内部类

局部内部类就是在一个类的方法中创建另一个类

有名局部内部类

这里的Comparator是jdk自带的一个接口

 public Comparator getComparator(){
        //局部内部类
        class childern implements Comparator{
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
            public void show(){
                System.out.println("这是局部内部类的方法");
            }
        }
        Comparator ch1=new childern();
        return ch1;
    }

匿名局部内部类

这里的从–>到<–里的部分是实现接口的内部类，但是没有名字，直接new了

public Comparator getComparator2(){
        Comparator cm1=new Comparator() A---->{
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
            public void show2(){
                System.out.println("这是匿名内部类的方法");
            }
        };<----
        //这里的大括号里就是内部类，实现了Comparator这个接口，但是这个内部类没有名字 注意：这里大括号后有个“；”
        return cm1;
    }

注意

局部内部类使用同级别的属性时，其内部类中的同级别属性为final类型，不可以进行修改

枚举类

自定义枚举类

构造器私有化 类的内部创建枚举类
注意这里的枚举类定义为static final

private String description;
        private String month;

        public static final season Spring=new season("春天百花开","2-4");
        public static final season Summer=new season("夏天蝉鸣叫","5-7");
        public static final season Autumn=new season("秋天枫叶红","8-10");
        public static final season Winter=new season("冬天白雪飘","11-1");
        private season(String description, String month) {
            this.description = description;
            this.month = month;
        }

        @Override
        public String toString() {
            return "sesaon{" +
                    "description='" + description + '\'' +
                    ", month='" + month + '\'' +
                    '}';
        }

enum创建枚举类

使用enum创建枚举类时枚举类方法最上面，且直接枚举类名字实现构造器即可，每个枚举类之间逗号隔开，知道最后句号结尾

Spring("春天百花开","2-4"),
    Summer("夏天蝉鸣叫","5-7"),
    Autumn("秋天枫叶红","8-10"),
    Winter("冬天白雪飘","11-1");

枚举类实现接口

public enum season2 implements myinterfacce {//


    Spring{
        @Override
        public void show() {
            System.out.println("这是春天");
        }
    },
    Summer{
        @Override
        public void show() {
            System.out.println("这是夏天");
        }
    },
    Autumn{
        @Override
        public void show() {
            System.out.println("这是秋天");
        }
    },
    Winter{
        @Override
        public void show() {
            System.out.println("这是冬天");
        }
    };

}

注解

java内置的注解

①@Override 用于注解重写方法 其下面的方法必须为重写方法
②@Deprecated 用于注解类、属性、方法 说明其已经过时，不建议使用
③@SuppressWarings 用于抑制编译器警告

自定义注解（和类是同级关系）

public @interface 注解名

元注解（描述注解的注解）

①@Rention 用于说明注解的生命周期
②@Target 用于说明注解可以修饰哪些程序元素
③@Document 用于说明注解可以自动生成说明文档 注意：此时的生命周期必须是@Rention（RUNTIME）
④@Inherited 用于说明注解有继承性