【Java进阶篇】第一章 面向对象

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

---

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

---

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

---

开始前，整理一下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{

}
1
2
3
4
5
6

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

class A{
    public final void method(){
        
    }
}
class B extends A{
    public final void method(){
        System.out.println("尝试覆盖");
    }
}
1
2
3
4
5
6
7
8
9
10

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

注意：

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

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

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

public static void main(String[] args) {
     final int var;
     var = 11;
     var = 12;
}
1
2
3
4
5

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

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

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

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

小总结：

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

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

static final String COUNTRY = "中国";
1

关于常量：

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

final总结：

---

• final修饰的类无法继承
• final修饰的方法无法覆盖
• final修饰的变量只能赋一次值
• final修饰的引用一旦指向某个对象，则不能再重新指向其他对象，但该引用所指向的对象的内部属性数据是可以修改的
• final修饰的实例变量必须手动初始化，不能采用系统默认值
• final修饰的实例变量一般和static联合使用，成为常量

2、抽象类

认识抽象类：

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

抽象类的语法定义：

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

抽象类的特点总结：

• 抽象类是无法实例化的，无法创建对象，所以抽象类是用来被子类继承的
• 没有final abstract这种组合（final代表不能被继承，abstract类是用来被子类继承的）
• 抽象类的子类可以是抽象类
• 抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类提供的（super）

详解：

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

//没有final abstract这种组合
final abstract class TestClass{
    
}
1
2
3
4

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

}

abstract class TestClass extends AbstractTest{

}
1
2
3
4
5
6
7
8

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

}

class TestClass extends AbstractTest{ //报错
 
}
1
2
3
4
5
6
7
8
9
10
11

小复习：

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

抽象方法：

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

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

1
2
3
4
5
6

需要注意的是：

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

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

}

class TestClass extends AbstractTest{//报错

}
1
2
3
4
5
6
7
8
9

abstract class AbstractTest{
    public abstract void doSome();

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

}

//如果子类还是抽象类，则不重写抽象方法也可以
abstract class TestClass2 extends AbstractTest{
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

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

3、接口

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

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

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

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

interface A{
}

interface B{
}

interface C extends A,B{
}
1
2
3
4
5
6
7
8

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

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

• 接口中所有元素都是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;
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

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

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

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

接口在开发中的作用：

降低程序的耦合度，提高程序的扩展力：

任何一个接口都有调用者和实现者，接口可以实现调用者和实现者的解耦合，调用者面向接口调用、实现者面向接口编写类和方法。

形象例子之-----厨师、菜单、顾客

• is a：Cat is a Animal —>is a 即继承关系
• has a：I has a pen—> has a 关联关系通常以属性的形式存在
• like a： cooker like a FoodMenu —>like a 即实现关系
  

抽象类和接口的区别：

• 抽象类是半抽象，接口是完全抽象
• 抽象类中有构造方法，接口中没有构造方法
• 接口和接口之间可以多继承，类和类之间只能单继承
• 一个类可以同时实现多个接口，一个抽象类只能继承一个类
• 接口中只允许出现常量和抽象方法，接口是对行为的提取

4、包和import机制

package是Java中的包机制，包机制的作用是为了方便管理，不同功能的类分别放在不同的包下。

• package是一个关键字，后面跟包名，如package com.javase
• package语句只允许出现在Java源代码的第一行
• 包名的命名规范是公司域名的倒序+项目名+模块名+功能名，如com.llg.javase.study
  
  

import机制：

• A类中使用了B类，如在A类中newB类型的对象，而A和B类在同一个包下，此时不用import，相反，A类和B类不在同一个包下，则需要import
• import语句只能出现在package语句之下，class类声明之上，import com.llg.*
• 注意别import java.* ,Java中的import，*只能代表某些类名