Java基础第五章、面向对象程序设计

1.package包

如果引入的不同包里面有相同的类名时，需要对要使用的类进行完整的限定名指定。

2.访问修饰符

子类对父类的方法重写也遵循上面的原则

一个java文件中最多只能有一个public(和文件同名)的类。

3.初始化块

java 复制代码

//Driver.java
public class Driver {
    private long licenceNo;
    private String name;
    private int year;


    //初始化块,编译器会将块中代码编入每一个构造器的开头
    {
        System.out.println("Init licenceNo.");
        licenceNo=System.currentTimeMillis();
    }


    public Driver(String name, int year) {
        this.name = name;
        this.year = year;
    }


    public long getLicenceNo() {
        return licenceNo;
    }


    public String getName() {
        return name;
    }


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


    public int getYear() {
        return year;
    }


    public void setYear(int year) {
        this.year = year;
    }


    public void introduce(){
        System.out.println("licenceNo:"+licenceNo);
        System.out.println("Name:"+name);
        System.out.println("year:"+year);


    }
}

java 复制代码

//Game.java
public class Game {
    public static void main(String[] args) {
        Driver driver1=new Driver("Tom",26);
        driver1.introduce();
    }
}

初始化执行顺序：

成员变量->初始化块->构造器

4.static关键字

类初始化执行顺序：

类变量(静态变量)->静态初始化块

5.final关键字

修饰方法时，方法无法被重写

final修饰引用类型变量（只能保证引用类型变量所引用的地址不变）

6.抽象类

抽象类：

子类Car：

子类Motorbike：

若子类是抽象类，可以不重写实现父类的抽象方法：

抽象类无法被实例化：

7.接口

default方法需要有个默认方法，需要写方法体

接口定义：

接口实现：

测试：

示例：灵活扩展

面向接口编程：

抽象类和接口对比：

8.内部类

(1)非静态内部类

非静态内部类代码：

java 复制代码

public class OuterFirst {
    private int width = 1024;
    public void print(){
        Inner inner=new Inner(1920,1080);
        //外部类调用内部类方法
        inner.print();
        //外部类调用内部类成员变量
        System.out.println("Outer visit Inner width:"+inner.width);
        System.out.println("Outer visit Inner height:"+inner.height);
    }


    static{
        //静态块中无法访问非静态内部类
    }


    public static void show(){
        //静态方法中无法访问非静态内部类
    }


    //非静态内部类
    public class Inner{
        //不可以定义静态成员、静态块、静态方法
        private int width;
        private int height;
        public Inner(int width,int height){
            this.width=width;
            this.height=height;
        }
        public void print(){
            //访问内部类成员变量
            System.out.println("Inner width:"+this.width);
            System.out.println("Inner height:"+this.height);
            //访问外部类成员变量
            System.out.println("Inner visit Outer width:"+OuterFirst.this.width);


        }
    }
}

调用演示：

java 复制代码

public class InnerDemo {
    public static void main(String[] args) {
        //访问非静态内部类
        //实例化Inner类（通过外部类的实例）
        OuterFirst.Inner finner=new OuterFirst().new Inner(1920,1080);
        finner.print();
    }
}

(2)静态内部类

(3)局部内部类（使用场景很少）

(4)匿名内部类（使用场景比较有特色，例如比较器）

9.枚举类

枚举中定义的各个类型中其实是枚举类的各个实例（比如说这里的MALE和FEMALE）

(1).枚举类如何实现接口

java 复制代码

//定义枚举类
public enum Season {
    SPRING, SUMMER, FALL, WINTER;
}

java 复制代码

//使用枚举类
public class EnumDemo {
    public static void main(String[] args) {
        //单独使用
        printSeasonWord(Season.SPRING);
        printSeasonWord(Season.SUMMER);
        System.out.println("遍历枚举类中所有的值:");
        //遍历枚举类中所有的值
        for(Season value:Season.values()){
            printSeasonWord(value);
        }
    }


    public static void printSeasonWord(Season season){
        switch (season){
            case SPRING:
                System.out.println("春天：万物复苏");
                break;
            case SUMMER:
                System.out.println("夏天：烈日炎炎");
                break;
            case FALL:
                System.out.println("秋天：硕果累累");
                break;
            case WINTER:
                System.out.println("冬天：白雪皑皑");
                break;
        }
    }
}

定义构造方法的枚举类：

java 复制代码

public enum Direction {
    //设置构造器以后需要使用指定的构造器
    EAST("东"),SOUTH("南"),WEST("西"),NORTH("北");
    private final String name;


    //设置构造器
    Direction(String name) {
        this.name = name;
    }


    //访问私有变量的方法
    public String getName(){
        return this.name;
    }
}

使用枚举类：

java 复制代码

//直接使用枚举类中实例的方法
System.out.println("Direction getName:"+Direction.EAST.getName());
System.out.println("遍历Direction枚举类中所有的值:");
for(Direction direction:Direction.values()){
    System.out.println("Direction Name:"+direction.getName());
}

枚举类实现接口示例：

方式一：通过Switch对实例进行判断并输出

java 复制代码

public enum Gender implements Printer{
    MALE,FEMALE;


    @Override
    public void printer() {
        switch (this){
            case MALE:
                System.out.println("男");
                break;
            case FEMALE:
                System.out.println("女");
                break;
        }
    }
}


interface Printer{
    void printer();
}

java 复制代码

//调用测试
System.out.println("枚举类实现定义的接口：");
Gender.MALE.printer();
Gender.FEMALE.printer();

方式二：直接通过实例的内部去分别实现

java 复制代码

MALE(){
    @Override
    public void printer() {
        System.out.println("男");
    }
},

FEMALE(){
    @Override
    public void printer() {
        System.out.println("女");
    }
};

(2).枚举类实现抽象方法

java 复制代码

public enum State {
    ON(){
        @Override
        public void print() {
            System.out.println("开关打开！");
        }
    },
    OFF(){
        @Override
        public void print() {
            System.out.println("开关关闭！");
        }
    };
    public abstract void print();
}

java 复制代码

//调用测试
System.out.println("枚举类实现抽象方法：");
State.ON.print();
State.OFF.print();

10.引用类型数组（数组中存放的地址）

示例代码：

java 复制代码

public class ReferenceDemo {
    public static void main(String[] args) {
        //静态初始化引用类型数组Cars
        Car[] cars = {
                new Car("奔驰"),
                new Car("宝马"),
                new Car("奥迪")
        };
        for (Car car : cars) {
            car.run();
        }


        //动态初始化引用类型数组Drivers
        Driver[] drivers = new Driver[3];
        drivers[0] = new Driver("Tom");
        drivers[1] = new Driver("Amy");
        drivers[2] = new Driver("Daming");
        for (Driver driver : drivers) {
            driver.introduce();
        }
    }
}


class Car {
    private String brand;


    public Car(String brand) {
        this.brand = brand;
    }


    public void run() {
        System.out.println("brand:" + brand);
    }
}


class Driver {
    private String name;


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


    public void introduce() {
        System.out.println("My name is " + name);
    }
}