Java学习——day 05

主要内容

• 抽象类
• 接口
• 内部类
• 数组
• 三种字符声明方式

笔记详情

1. 抽象类

抽象类是一种模板模式，抽象类为子类提供一个模板，子类在抽象类的模板基础之上进行扩展。相当于提出一个规范，子类来执行这个规范。使用抽象类可以避免子类设计的随意性，限制子类的设计，使得子类之间更加通用。总体来说，抽象类有以下几个特点：

1. 抽象类中不仅可以包含抽象方法，还可以包含正常类中的构造函数，属性和方法。但是不能使用抽象类来new一个对象。

2. 有抽象方法的类必须定义抽象类。

3. 抽象类只能被用来继承，继承抽象类的子类，必须重写以实现抽象类中的抽象方法。

下面给出一个抽象类的实例：

// 抽象类必须使用abstract来修饰定义
public abstract class Animal {

    // 抽象类中可以包含属性，构造函数，方法和抽象方法
    String name = "动物";

    public Animal() {
        System.out.println("初始化一个动物");
    }

    public void say() {
        System.out.println("普通动物的叫");
    }

    public abstract void run();

}

// 继承抽象类的类，必须重写抽象类中的抽象方法
class Cat extends Animal {

    @Override
    public void run() {
        System.out.println("小猫，跑跑");
    }
}

2. 接口

接口是一种规范，是比抽象类还抽象的“抽象类”。接口中只能包含常量和抽象方法，并且在定义的时候，可以不加修饰符，定义接口可以完成：设计与实现的分离。比如你的项目经理给你明确了需求，给你定义了接口，那么你就可以在后续的编程中，实现接口中的内容，完成需求。下面给出接口的实例：

public interface InterfaceA {
    // 接口中只能包含常量和抽象方法
    int MAX_SPEED = 120;
    String MESSAGE = "这是一个常量字符串";

    public void showMessage();

    public int add(int a, int b);
}

class C implements InterfaceA {
    // 实现接口的类中，必须要重写以实现接口中的抽象方法
    @Override
    public void showMessage() {
        System.out.println(InterfaceA.MESSAGE);
    }

    @Override
    public int add(int a, int b) {
        return a + b;
    }
    // 同时，该类还可以定义自己的方法
    public void ccc() {
        System.out.println("我是C类自己的方法");
    }
}

在Java中，类是不能实现多继承的，但是一个类可以实现多个接口，从而间接实现多继承：

public interface InterfaceA {
    // 接口中只能包含常量和抽象方法
    int MAX_SPEED = 120;
    String MESSAGE = "这是一个常量字符串";

    public void showMessage();

    public int add(int a, int b);
}

interface InterfaceB {
    int MAX_HEIGHT = 10;

    public void showHello();
}

class C implements InterfaceA, InterfaceB {

    @Override
    public void showMessage() {
        System.out.println(InterfaceA.MESSAGE);
    }

    @Override
    public int add(int a, int b) {
        return a + b;
    }

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

    public void ccc() {
        System.out.println("我是C类自己的方法");
    }

}

接口除了可以被实现（implements），还可以被继承（extends），且这个时候，一个接口可以继承多个接口。

public interface InterfaceA {
    // 接口中只能包含常量和抽象方法
    int MAX_SPEED = 120;
    String MESSAGE = "这是一个常量字符串";

    public void showMessage();

    public int add(int a, int b);
}

interface InterfaceB {
    int MAX_HEIGHT = 10;

    public void showHello();
}

// 接口可以继承多个接口
interface InterfaceC extends InterfaceA, InterfaceB {
    public void show();
}

// 不仅要实现接口C中的抽象方法，还要实现接口C继承的接口中的方法
class C implements InterfaceC {

    @Override
    public void showMessage() {
        System.out.println(InterfaceA.MESSAGE);
    }

    @Override
    public int add(int a, int b) {
        return a + b;
    }

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

    public void ccc() {
        System.out.println("我是C类自己的方法");
    }

    @Override
    public void show() {
        System.out.println("我是接口C中的方法");

    }
}

3. 内部类

内部类，顾名思义就是在一个类的内部在定义一个类。一般情况下，如果在程序中，一个类只使用到一次，且这个类只是用来服务另一个类的，这个时候就可以使用内部类。内部类可以直接访问外部类中的属性和方法，但是外部类却不一定能够访问内部类中的属性和方法。

内部类分为静态内部类和非静态内部类，如果是静态内部类，外部类可以内部类中的静态属性和方法，但是不能访问静态内部类中的非静态属性和方法。下面给出静态类的实例：

public class Computer {
    double width;
    double height;
    String brand;

    // 访问静态类中的属性和方法
    public void show() {
        System.out.println(Screen.test);
        Screen.show();
    }

    // 定义静态内部类
    static class Screen {
        static String test = "静态内部类中的数据";

        public static void show() {
            System.out.println("静态内部类");
        }
    }

    public static void main(String[] args) {
        Computer dell = new Computer();

        dell.brand = "dell";
        dell.show();

        Screen.show();      // 可以通过内部类直接调用内部类中的方法
    }

}

如果是非静态内部类，外部类不能够访问内部类中的属性和方法。下面给出静态类的实例：

public class Computer {
    double width;
    double height;
    String brand;

    class Cpu {
        String brand;

        public void show() {
            System.out.println(brand);
            System.out.println(Computer.this.brand);
        }
    }


    public static void main(String[] args) {
        Computer dell = new Computer();

        dell.brand = "dell";

        Computer.Cpu cpu = dell.new Cpu();      // 主力这里生命内部类实例的方法
        cpu.brand = "dell Cpu";
        cpu.show();
        
    }

}

4. 数组

数组是Java中常见的数据类型，这里我们需要知道数组定义和初始化的几种方法：

数组的定义方法如下：

int arrayA[];
int[] arrayB;

初始化数组的三种方法：

// 1. 默认初始化，在定义的时候系统会自动初始化，初始化的规则是：
// 数字：0；布尔值：false；字符型：\u0000；引用类型：null

// 2. 静态初始化
int arrayC[] = { 22, 55, 33, 66 };

// 3. 动态初始化
int arrayD[] = new int[4];

arrayD[0] = 12;
arrayD[1] = 23;
arrayD[2] = 34;
arrayD[3] = 45;

5. 三种字符声明方式

String：不可变长度字符；
StringBuilder：可变长度字符，线程不安全，但是很高效；
StringBuffer：可变长度字符，线程安全，但是效率低。

String userName1 = "fengzhen";
StringBuilder userName2 = new StringBuilder("fengzhenzhen");
StringBuffer userName3 = new StringBuffer("feng");

// 可变字符，可以通过append来扩展字符
userName2.append(666).append("true").append(false);    // fengzhenzhen666truefalse
userName3.append(666).append("true").append(false);    // feng666truefalse