⭐⭐⭐Java基础篇目录⭐⭐⭐

🍁 第一章 Java开发环境搭建
🍁 第二章标识符与关键字
🍁 第三章变量
🍁 第四章数据类型
🍁 第五章运算符
🍁 第六章控制语句
🍁 第七章方法
🍁 第八章认识面向对象
🍁 第九章对象的创建和使用
🍁 第十章封装
🍁 第十一章 this和static
🍁 第十二章继承
🍁 第十三章方法的覆盖和多态
🍁 第十四章 super

在以上的基础上，接着开始整理Java进阶篇后续章节的笔记。

文章目录

1、final关键字
2、抽象类
3、接口
4、包和import机制

开始前，整理一下Java集成开发工具Intellij IDEA的快捷键：

快速生成main方法——>psvm

快速生成println——>sout

删除光标所在的这一行——>Ctrl+Y

快速新增、插入，如setter和getter——>Alt+Insert

纠正错误——>Alt+Enter

提示方法的参数——>Ctrl+P

搜索某类的源代码，如String类——>Shift+Shift

显示一个Java文件中的所有方法——>Ctrl+F12

多行注释——>选中后Ctrl+shift+/

切换窗口——>Alt+左右箭头

1、final关键字

final是Java语言的一个关键字，表示最终的，不可变的
final可以修饰变量、方法和类

final class A{

}
class B extends A{

}

🍁final修饰的类不能被继承。类加了final就像某个人宣布不要孩子。

class A{
    public final void method(){
        
    }
}
class B extends A{
    public final void method(){
        System.out.println("尝试覆盖");
    }
}

🍁final修饰的方法不能被覆盖，加了final的方法，就像一个不能更改的祖传秘方。

注意：

final修饰的方法只是不能被覆盖，至于调用，该咋样还是咋样。

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

public static void main(String[] args) {
       final int var = 10;
       var = 11;
}

public static void main(String[] args) {
     final int var;
     var = 11;
     var = 12;
}

🍁final修饰的引用，只能指向一个对象，并且只能永远指向这个对象（即只能赋一次值）

class Persons{
	public static void main (String[] args){
		final Persons persons = new Persons();
		persons = null;
	}
}
//不能被赋null，这个对象不能被GC机制回收，但persons是局部变量，方法执行结束后persons会释放，也就没了

引用本质是一个存放堆区中对象内存地址的变量，也不能被重新赋值，所以这条拴着气球的线不会断，但对象属性内部可以被更改。

🍁final修饰的实例变量，系统不管赋默认值，必须手动赋值，这个手动赋值，在变量后面直接赋值行，在构造方法中赋值也行。 但当所有对象的某个属性都一样时，其实也没必要用实例变量了，直接静态变量static就行。

小总结：

final修饰的变量，只能赋一次值。

🍁static和final联合修饰的变量称为常量，常量名全部字母大写，各单词之间用下划线连接

static final String COUNTRY = "中国";

关于常量：

实际上常量和静态变量一样，二者都存储在方法区，且都在类加载时初始化，区别在于常量的值不能变。
常量一般都是公开的，不用封装，因为反正也改不了

final总结：

final修饰的类无法继承

final修饰的方法无法覆盖

final修饰的变量只能赋一次值

final修饰的引用一旦指向某个对象，则不能再重新指向其他对象，但该引用所指向的对象的内部属性数据是可以修改的

final修饰的实例变量必须手动初始化，不能采用系统默认值

final修饰的实例变量一般和static联合使用，成为常量

2、抽象类

认识抽象类：

类和类之间也有共同的特征，将这些共同特征再进一步抽象，就形成了抽象类，由于抽象类的下一级是类，实际生活中不存在，故抽象类不能实例化。抽象类也属于引用数据类型。

抽象类的语法定义：

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

抽象类的特点总结：

抽象类是无法实例化的，无法创建对象，所以抽象类是用来被子类继承的

没有final abstract这种组合（final代表不能被继承，abstract类是用来被子类继承的）

抽象类的子类可以是抽象类

抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类提供的（super）

详解：

//抽象类的下一级是类，不能实例化
abstract class AbstractTest{
    public static void main(String[] args) {
        AbstractTest abstractTest = new AbstractTest();
    }
}

//没有final abstract这种组合
final abstract class TestClass{
    
}

//抽象类的子类可以是抽象类
abstract class AbstractTest{

}

abstract class TestClass extends AbstractTest{

}

//抽象方法无法实例化，但有供子类使用的构造方法
abstract class AbstractTest{
    public AbstractTest(String s){
        System.out.println("顶掉系统默认的无参构造");
    }

}

class TestClass extends AbstractTest{ //报错
 
}

小复习：

当构造方法的第一行，既没有this(……）又没有super(……)的时候，默认会有一个super()，表示通过当前子类的构造方法调用父类的无参构造方法，所以必须保证父类中的无参构造方法是存在的

抽象方法：

抽象方法表示没有实现的方法，没有方法体的方法。比如：

public abstract void doSome();
//特点是：
- 无方法体
- ；结尾
- abstract关键字

需要注意的是：

抽象类中不一定有抽象方法（抽象类中抽象方法、非抽象方法都可以有）
有抽象方法的，只能是抽象类
非抽象类继承抽象类，必须将抽象方法实现（重写/覆盖）

//未重写（实现）抽象方法
abstract class AbstractTest{
    public abstract void doSome();

}

class TestClass extends AbstractTest{//报错

}

abstract class AbstractTest{
    public abstract void doSome();

}
//非抽象类继承抽象类，必须重写抽象类中的抽象方法
class TestClass extends AbstractTest{
    public void doSome(){
        
    }

}

//如果子类还是抽象类，则不重写抽象方法也可以
abstract class TestClass2 extends AbstractTest{
    
}

没有方法体的方法就一定是抽象方法？（错！！）

//动态链接库程序
public native int hashCode();

3、接口

接口也是一种引用数据类型
接口是完全抽象的（抽象类是半抽象）
接口的定义语法：

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

}
//虽然没有class关键字，但编译完还是.class文件

接口支持继承，且一个接口可以继承多个接口

interface A{
}

interface B{
}

interface C extends A,B{
}

接口中只包含两部分内容，一部分是常量，一部分是抽象方法，接口中再没其他内容

interface MyMath{
	public abstract int sum (int a,int b);//抽象方法
}
//接口中均为抽象方法，故public abstract省略也可以，int sum (int a, int b);

接口中所有元素都是public修饰，都是公共的
接口中抽象方法定义时，public abstract可省略，同样的常量的public static final double PI =3.1415929;中，public static final也可省略
接口中的方法都是抽象方法，故不能有方法体{ }，直接封号；
常量的调用：接口名.常量名，如MyMath.PI

总之，”特殊的抽象类，完全抽象的，叫做接口“

接口的实现

类和类之间叫做继承extends，类和接口之间叫做实现implements（实现可作是继承）

interface Maths{
    double PI = 3.1415926;
    int sum(int a, int b);
    double sub(int a, int b);
}
//当一个非抽象类实现接口，则必须将接口中的所有抽象方法全部实现（重写）
class MathsImpl implements Maths{
    public int sum(int a,int b){
        return a+b;
    }
    //由于接口中的方法是public，重写是也只能是public
    public double sub(int a, int b){
        return a+b+Maths.PI;
    }
}

接口是抽象的，不能创建对象，但可以用为父类型的引用来指向子类型的对象。

public class Test    {
    public static void main(String[] args) {
        Maths maths = new MathsImpl();
        maths.sub(1,2);
        maths.sum(1,2);
    }
}

接口和接口之间支持多继承，一个类也可以同时实现多个接口（这也弥补了类之间的单继承的缺陷）。类比生活中的计算机主机，一个机箱上可以挂多个接口，一个接口接键盘，一个键盘接鼠标，一个接口接电源，一个接口接显示器……

interface A{
    void m1();

}
interface B{
    void m2();

}
interface C{
    void m3();

}

class D implements A,B,C{
    public void m1(){

    }
    public void m2(){

    }
    public void m3(){

    }
}

public class Test1 {
    public static void main(String[] args) {
        A a = new D();
        B b = new D();
        C c = new D();
        a.m2();//报错，编译阶段不通过，A类中无m2()方法
        //此处A和B接口虽然无直接的继承关系，但可以转成功
        B a1 = (B)a;
        a1.m2();
    }
}

extends和implements同时出现，extends写在前

/**
 * 动物类、父类
 */
class Animals_{

}

/**
 * 可飞翔的接口
 * 就像一对职棒
 */
interface Flyable{
    void fly();
}

/**
 * 继承Animals类并且实现Flyable接口
 */
class Cat_ extends Animals_ implements Flyable{
    public void fly(){
        System.out.println("飞猫");
    }
}

/**
 * 不想让猪飞，则不实现Flyable接口
 * ！！！这就是接口提取行为动作、可插拔
 */
class Pig extends Animals_{
    
}

public class FlyTest {
    public static void main(String[] args) {
        Flyable f = new Cat_();
        f.fly();
    }
}