java学习笔记——抽象类、接口、内部类、枚举 和 注解

抽象类

1. 为什么使用抽象类？
类用于描述现实生活中的一类事物，类中属性、方法，方法都有方法体。
某种情况下，父类只能知道子类应该具备一个怎样的方法，但是不能明确知道子类如何实现该方法。
例如：几何图形（多态练习）。所有几何图形都应该具备一个计算面积的方法，但是不同几何图形计算面积的方式不同

Java 为上述问题提供了相应的解决办法：
Java 允许父类只是提供一个方法的声明，不提供具体的实现
具体的实现交给子类来完成，该方法称为“抽象方法”
拥有一个或多个抽象方法的类，称为“抽象类”

2. 如何使用抽象类？
关键字：abstract
abstract 修饰的类称为“抽象类”
①格式：访问控制修饰符 abstract class 类名{}
②抽象类中可以有非抽象方法，抽象类中可以没有抽象方法
③拥有一个或多个抽象方法的类，必须是抽象类
④**抽象类不能创建实例
⑤抽象类中可以声明构造器。
    目的：当子类继承父类后，继承父类中所有的属性和方法，因此子类需要知道父类如何为对象进行初始化

abstract 修饰的方法称为“抽象方法”
①格式：访问控制修饰符 abstract 返回值类型 方法名(参数列表);
②子类继承父类后，若重写了父类中“所有”的抽象方法，该类为具体类，可以创建实例
③子类继承父类后，若没有重写父类中“所有”的抽象方法，该类必须是抽象类，不能创建实例

3.注意
abstract 和 final 不能同时使用
abstract 和 static 不能同时使用

abstract 和 private 不能同时使用

接口

①接口与类是平级的。
        关键字：interface
        如：
        public interface Flyer{}      
②可以把接口理解为特殊的抽象类，因为接口中只能定义“全局静态常量”和“抽象方法”
        //全局静态常量
        int NUM = 10;//等同于public static final int NUM = 10;
        //抽象方法
        void fly();//等同于public abstract void fly();
③接口中不能使用变量、一般方法、构造器、代码块
④**接口不能创建实例
⑤接口就是用来被实现的
        关键字：implements
        如：
        public class Bird implements Flyer{}
⑥实现接口的类称为“实现类”，实现类与“继承”的功能一样，实现类可以“继承”接口中所有内容
⑦若实现类没有实现接口中“所有”的抽象方法，该类必须是抽象类，不能创建实例
    若实现类实现了接口中“所有”的抽象方法，该类为具体类，可以创建实例
⑧接口可以多实现 ------ 解决了 Java 中单继承的局限性
        如：
        public class Bird implements Flyer, Runner{}
⑨接口不能继承任何类，接口可以继承接口，并且可以多继承接口
⑩一个类可以继承另一个类，同时实现多个接口
        如：
        pulbic class Bird extends Animal implements Flyer, Runner{}
        注意：先继承，后实现

        Flyer f = new Bird();//多态

        f.fly(); //虚拟方法调用

内部类

类的成员之一：内部类（属性、方法、构造器、代码块）
        
        1.成员内部类：一个类中声明另一个类，里面的类，称为“内部类”，外面的类，称为“外部类”
            ①是类的成员之一
            ②内部类可以使用四种访问控制修饰符（public protected default private）
            ③static  final

                //创建静态内部类的对象
                Person.Mobile pm = new Person.Mobile();
                pm.show();

                //创建非静态内部类对象
                Person p = new Person();
                Person.Computer pc = p.new Computer();

                Person.Computer pc2 = new Person().new Computer();
                
                pc.setName("IBM");

            ④内部类与外部类具有相同的特性

        class Person{
            private String name;
            private int age;

            public Person(){}

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

            //成员内部类
            public class Computer{
                private String name;
                
                public void setName(String name){
                    System.out.println(age);
                    System.out.println("局部变量 name:" + name);
                    System.out.println("当前 Computer 对象的 name:" + this.name);
                    System.out.println("当前 Person 对象的 name:" + Person.this.name);
                    this.name = name;
                }
            }

            //实现对类的隐藏
            private class Heas{}

            //静态内部类
            static class Mobile{
                public void show(){}
            }
        }

        2.局部内部类：

        //如下方式应用较少
        public void show(){
            int num = 10;//若局部内部类中使用了同级别的局部变量时，该局部变量必须使用 final 修饰
        
            //局部内部类
            class InnerClass{

            }

            InnerClass inner = new InnerClass();
            
        }

        //若某个类仅适用于当前方法时，可以声明如下：
        public Comparator getComparator(){
            //局部内部类
        class MyComparator implements Comparator{
            public int compare(Object o1, Object o2){}
        }

            return new MyComparator();
        }

        Comparator com = getComparator();
        com.compare(1,2);

        public Comparator getComparator(){
            //匿名内部类
            Comparator com  = new Comparator(){
                public int compare(Object o1, Object o2){}
            };

            return com;
        }

        public Comparator getComparator(){
            return new Comparator(){
                public int compare(Object o1, Object o2){}    
            };
        }

枚举

枚举：jdk 1.5 后出的新特性。可以定义有限数量的可穷举数据集
           简而言之，当确定一个类有几个对象时，就使用枚举

1. 自定义枚举类
①私有化构造器
②类的内部创建对象

/*
 * 自定义枚举类
 */
public class Season2 {

    private String seasonName;
    private String seasonDesc;

    // 2. 类的内部创建对象
    public static final Season2 SPRING = new Season2("春天", "春眠不觉晓");
    public static final Season2 SUMMER = new Season2("夏天", "处处蚊子咬");
    public static final Season2 AUTUMN = new Season2("秋天", "秋天叶子黄");
    public static final Season2 WINTER = new Season2("冬天", "冬天雪花飘");

    // 1. 私化构造器
    private Season2(String seasonName, String seasonDesc) {
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    public String getSeasonName() {
        return seasonName;
    }

    public void setSeasonName(String seasonName) {
        this.seasonName = seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    public void setSeasonDesc(String seasonDesc) {
        this.seasonDesc = seasonDesc;
    }

    @Override
    public String toString() {
        return "Season [seasonName=" + seasonName + ", seasonDesc=" + seasonDesc + "]";
    }

}

2. enum 关键字创建枚举类

public enum Season2 {

    SPRING,
    SUMMER,
    AUTUMN,
    WINTER;

}


3. 枚举类实现接口
public enum Season implements MyInterface{
    
    SPRING{
        public void show(){
            System.out.println("春天");
        }
    },
    SUMMER{
        public void show(){
            System.out.println("夏天");
        }
    },
    AUTUMN{
        public void show(){
            System.out.println("秋天");
        }
    },
    WINTER{
        public void show(){
            System.out.println("冬天");
        }
    };

    /*@Override
    public void show() {
        System.out.println("季节");
    }*/

}

注解