1.final关键字

final修饰的类无法继承

final修饰的方法无法被覆盖，被重写。

final修饰的局部变量，一旦赋值，就不能再赋值。

final修饰的引用，只能指向同一个对象，不能再指向其它对象。在该方法中，该引用指向该对象后，该对象不会被垃圾回收器回收。直到该方法结束。

fianl修饰的实例变量，系统不管，程序员必须手动赋值。在变量后面赋值可以，在构造方法中赋值也可以。

2.常量

final修饰的实例变量一般添加static修饰。

3.抽象类

3.1概括

类和类之间有共同特征，将共同特征提取出来，构成抽象类。

抽象类也属于引用数据类型。

语法：

[修饰符列表] abstract class 类名 {
 	类体;
}

抽象类无法被实例化，但抽象类有构造方法，供子类使用。

3.2 抽象方法

抽象类不一定有抽象方法，抽象方法一定在抽象类中。

非抽象类继承抽象类的时候，非抽象类要将父类继承过来的抽象方法进行重写。

4. 接口

接口也是一种引用数据类型，编译后也生成.class字节码
语法：

[修饰符列表] interface 接口名{}

接口支持多继承

接口中只有常量和抽象方法。

接口中的方法定义时 public abstract 可以省略。
接口中的常量定义时 public static final 可以省略。

类和接口之间叫做实现。使用implements关键字。
类和类之间叫做继承。使用extends关键字。

当一个非抽象类实现一个接口时，必须重写接口中的所有抽象方法。

4.1 接口在开发中的作用

4.2类型和类型之间的关系

4.3抽象类和接口的区别

5.包机制和import

5.1 包机制

package 包名

注：该语句只能出现在java源代码的第一行。
包名一般为:公司域名倒序 + 项目名 + 模块名 + 功能名

使用包机制后，编译

javac -d . HelloWorld.java

运行使用

java 包名.原来的类名

（类名改变）

5.2 import

6.访问控制权限

7.Object

7.1 toString()

package com.sdnu.test01;

public class MyTime {
    public static void main(String[] args) {
        TestTime testTime = new TestTime();
        System.out.println(testTime.toString());
        TestTime testTime1 = new TestTime(2000, 2, 6);
        System.out.println(testTime1.toString());
    }
}
class TestTime {
    int year;
    int month;
    int day;
    public TestTime(){
    }
    public TestTime(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
    }

    /**
     * 重写
     * @return String
     */
    public String toString(){
        return "testTime" + "@" + this.year + "\\" + this.month + "\\" + this.day;
    }
}

testTime@0\0\0
testTime@2000\2\6

7.2 equals()

该方法返回是否是同一个对象。

package com.sdnu.test01;

import java.util.Objects;

public class TestEquals {
    int year;
    int month;
    int day;

    public TestEquals() {
    }

    public TestEquals(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public int getYear() {
        return year;
    }

    public int getMonth() {
        return month;
    }

    public int getDay() {
        return day;
    }

    @Override
    public String toString() {
        return "TestEquals{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        TestEquals that = (TestEquals) o;
        return year == that.year &&
                month == that.month &&
                day == that.day;
    }
    
    public static void main(String[] args) {
        TestEquals testEquals = new TestEquals();
        TestEquals testEquals1 = new TestEquals(2000, 2, 8);
        System.out.println(testEquals.equals(testEquals1));
    }
}

7.3 String类重写了toString和equals

8.内部类

8.1 概述

在类的内部又定义了一个新的类。
分类：静态内部类，实例内部类，局部内部类。

8.2内部类示例

package com.sdnu.test01;

public class Inner {
    static class Inner1{

    }
    class Inner2{

    }
    public void method(){
        class Inner3{

        }
    }
}

8.3 匿名内部类

9.数组

9.1声明

类型[] 数组名

9.2 初始化

静态初始化：

类型[] 数组名 = {12， 23， 45};

动态初始化：

类型[] 数组名 = new 类型[数组长度];

9.3 main方法的String数组

9.4数组扩容

创建一个大的数组，然后将小数组的数据拷贝到大数组中。

package com.sdnu.javase.array;

public class ArrayTest01 {
    public static void main(String[] args) {
        int[] src = {12, 23, 45};
        int[] dest = new int[20];
        System.arraycopy(src, 0, dest, 0, src.length);
        for(int i = 0; i < src.length; i++){
            System.out.println(dest[i]);
        }
    }
}

9.5 二维数组

声明和初始化

int 数组名[][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

9.6Array

java.util.Arrays