【Java编程】JavaSE基础总结（二）：面向对象

G皮T

已于 2023-10-16 20:21:02 修改

阅读量224

点赞数 3

分类专栏： # Java 基础文章标签： java 面向对象封装继承多态内部类枚举类

于 2022-09-12 11:00:05 首次发布

本文链接：https://blog.csdn.net/Be_racle/article/details/126807318

版权

Java 基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

【JavaSE】系列包含：

1.面向对象基础

面向对象程序设计（Object Oriented Programming）

对象基于类创建，类相当于一个模板，对象就是根据模板创建出来的实体（就像做月饼，我们要做一个月饼首先需要一个模具，模具就是我们的类，而做出来的月饼，就是类的实现，也叫做对象），类是抽象的数据类型，并不能代表某一个具体的事物，类是对象的一个模板。类具有自己的属性，包括成员变量、成员方法等，我们可以调用类的成员方法来让类进行一些操作。

所有的对象，都需要通过 new 关键字创建，基本数据类型不是对象！Java不是纯面对对象语言！

不是基本类型的变量，都是引用类型，引用类型变量代表一个对象，而基本数据类型变量，保存的是基本数据类型的值，我们可以通过引用来对对象进行操作。

2.类的基本结构

2.1 成员变量

在类中，可以包含许多的成员变量，也叫成员属性，成员字段（field）通过 . 来访问我们类中的成员变量，我们可以通过类创建的对象来访问和修改这些变量。成员变量是属于对象的！

public class Test {
    int age;
    String name;
}

public static void main(String[] args) {
    Test test = new Test();
    test.name = "奥利给";
    System.out.println(test.name);
}

方法是语句的集合，是为了完成某件事情而存在的。完成某件事情，可以有结果，也可以做了就做了，不返回结果。比如计算两个数字的和，我们需要得到计算后的结果，所以说方法需要有返回值；又比如，我们只想吧数字打印在控制台，只需要打印就行，不用给我结果，所以说方法不需要有返回值。

2.2 成员方法

传入方法的参数，如果是基本类型，会在调用方法的时候，对参数的值进行复制，方法中的参数变量，不是我们传入的变量本身！
传入方法的参数，如果是引用类型，那么传入的依然是该对象的引用！（类似于C语言的指针）

成员方法和成员变量一样，是属于对象的，只能通过对象去调用！

2.3 方法的重载

一个类中可以包含多个同名的方法，但是需要的形式参数不一样。（补充：形式参数就是定义方法需要的参数，实际参数就传入的参数）方法的返回类型，可以相同，也可以不同，但是仅返回类型不同，是不允许的！

public class Test {
    int a(){   //原本的方法
       return 1;
    }

    int a(int i){  //ok，形参不同
        return i;
    }
    
    void a(byte i){  //ok，返回类型和形参都不同
        
    }
    
    void a(){  //错误，仅返回值类型名称不同不能重载
        
    }
}

2.4 构造方法

构造方法（构造器）没有返回值，也可以理解为，返回的是当前对象的引用！每一个类都默认自带一个无参构造方法。

这种方法没有写明返回值，但是每个类都必须具有这个方法！只有调用类的构造方法，才能创建类的对象！类要在一开始准备的所有东西，都会在构造方法里面执行，完成构造方法的内容后，才能创建出对象！一般最常用的就是给成员属性赋初始值。

public class Student {
    String name;
    
    Student(){
        name = "伞兵一号";
    }
}

我们可以手动指定有参构造，当遇到名称冲突时，需要用到 this 关键字。

public class Student {
    String name;

    Student(String name){   // 形参和类成员变量冲突了，Java 会优先使用形式参数定义的变量！
        this.name = name;  // 通过 this 指代当前的对象属性，this 就代表当前对象
    }
}

注意，this 只能用于指代当前对象的内容，因此，只有属于对象拥有的部分才可以使用this，也就是说，只能在类的成员方法中使用 this，不能在静态方法中使用 this 关键字。

在我们定义了新的有参构造之后，默认的无参构造会被覆盖！如果同时需要有参和无参构造，那么就需要用到方法的重载！手动再去定义一个无参构造。

public class Student {
    String name;

    Student(){

    }

    Student(String name){
        this.name = name;
    }
}

成员变量的初始化始终在构造方法执行之前。

2.5 静态变量和静态方法

静态变量和静态方法是类具有的属性（后面还会提到静态类、静态代码块），也可以理解为是所有对象共享的内容。

我们通过使用 static 关键字来声明一个变量或一个方法为静态的，一旦被声明为静态，那么通过这个类创建的所有对象，操作的都是同一个目标，也就是说，对象再多，也只有这一个静态的变量或方法。那么，一个对象改变了静态变量的值，那么其他的对象读取的就是被改变的值。

public class Student {
    static int a;
}

public static void main(String[] args) {
	Student s1 = new Student();
	s1.a = 10;
	Student s2 = new Student();
	System.out.println(s2.a);
}

不推荐使用对象来调用，被标记为静态的内容，可以直接通过 类名.xxx 的形式访问。

public static void main(String[] args) {
   Student.a = 10;
   System.out.println(Student.a);
}

类并不是在一开始就全部加载好，而是在需要时才会去加载（提升速度）。以下情况会加载类：

访问类的静态变量，或者为静态变量赋值
new 创建类的实例（隐式加载）
调用类的静态方法
子类初始化时
其他的情况会在讲到反射时介绍

所有 被标记为静态的内容，会在类刚加载的时候就分配，而不是在对象创建的时候分配，所以说静态内容一定会在第一个对象初始化之前完成加载。

2.6 代码块和静态代码块

代码块在对象创建时执行，也是属于类的内容，但是它在构造方法执行之前执行（和成员变量初始值一样），且每创建一个对象时，只执行一次！（相当于构造之前的准备工作）

public class Student {
    {
        System.out.println("我是代码块");
    }

    Student(){
        System.out.println("我是构造方法");
    }
}

静态代码块和上面的静态方法和静态变量一样，在类刚加载时就会调用；

public class Student {
    static int a;

    static {
        a = 10;
    }
    
    public static void main(String[] args) {
        System.out.println(Student.a);
    }
}

2.7 String 和 StringBuilder

字符串类是一个比较特殊的类，他是 Java 中唯一重载运算符的类！(Java 不支持运算符重载，String 是特例)

String 的对象直接支持使用 + 或 += 运算符来进行拼接，并形成新的 String 对象！（String 的字符串是不可变的！）

public class Main {
    public static void main(String[] args) {
        String a = "dasdsa", b = "dasdasdsa";
        String l = a + b;
        System.out.println(l);
    }
}

大量进行字符串的拼接似乎不太好，编译器是很聪明的，String 的拼接有可能会被编译器优化为 StringBuilder 来减少对象创建（对象频繁创建时很费时间同时占内存的！）

String str1 = "String";
String str2 = "and";
String result = str1 + str2;
//变量随时可变，在编译时无法确定result的值，那么只能在运行时再去确定

String str1 = "String";
String str2 = "and";
String result = (new StringBuilder(String.valueOf(str1))).append(str2).toString();
//使用StringBuilder，会采用类似于第一种实现，显然会更快！

StringBuilder 也是一个类，但是它能够存储可变长度的字符串！

StringBuilder builder = new StringBuilder();
builder
       .append("a")
       .append("bc")
       .append("d");   //链式调用
String str = builder.toString();
System.out.println(str);

3.包和导入

包其实就是用来区分类位置的东西，也可以用来将我们的类进行分类。

package com.test;

public class Test{
  
}

包其实是文件夹，比如 com.test 就是一个 com 文件夹中包含一个 test 文件夹，再包含我们 Test 类。

一般包按照个人或是公司域名的规则倒过来写：顶级域名.一级域名.二级域名，比如：com.java.xxxx

如果需要使用其他包里面的类，那么我们需要 import。

import com.test.Student;

Java默认为我们导入了以下的包，不需要去声明。

import java.lang.*

静态导入 可以直接导入某个类的静态方法或者是静态变量，导入后，相当于这个方法或是类在定义在当前类中，可以直接调用该方法。

import static com.test.ui.Student.test;

public class Main {
    public static void main(String[] args) {
        test();
    }
}

Java 支持对类属性访问的保护，也就是说，不希望外部类访问类中的属性或是方法，只允许内部调用，这种情况下我们就需要用到权限控制符。

权限控制符可以声明在方法、成员变量、类前面，一旦声明 private，只能类内部访问！

public class Student {
    private int a = 10;   //具有私有访问权限，只能类内部访问
}

public static void main(String[] args) {
    Student s = new Student();
    System.out.println(s.a);  //还可以访问吗？
}

和文件名称相同的类，只能是public，并且一个 java 文件中只能有一个 public class！

// Student.java
public class Student {
    
}
class Test{   //不能添加权限修饰符！只能是default
	
}

访问控制：private、default、protected、public。

在这里插入图片描述

4.数组类型

数组本身也是类（编程不可见，C++写的），不是基本数据类型！

int[] arr = new int[10];  //需要new关键字来创建！
String[] arr2 = new String[10];

数组做实参，因为数组也是类，所以形参得到的是数组的引用而不是复制的数组，操作的依然是数组对象本身。

public static void main(String[] args) {
	int[] arr = new int[]{1, 2, 3};
	test(arr);
	System.out.println(arr[0]);
}

private static void test(int[] arr){
	arr[0] = 2934;
}

数组的循环

int[] arr = new int[]{1, 2, 3};
for (int i = 0; i < arr.length; i++) {
	System.out.println(arr[i]);
}

foreach 属于增强型的 for 循环，它使得代码更简洁，同时我们能直接拿到数组中的每一个数字。

int[] arr = new int[]{1, 2, 3};
for (int i : arr) {
    System.out.println(i);
}

二维数组和多维数组。

int[][] arr = new int[][]{ {1, 2},
                           {3, 4},
                           {5, 6}};
for (int i = 0; i < 3; i++) {
     for (int j = 0; j < 2; j++) {
          System.out.println(arr[i][j]);
     }
}

可变长参数 其实就是数组的一种应用，我们可以指定方法的形参为一个可变长参数，要求实参可以根据情况动态填入 0 个或多个，而不是固定的数量。

public static void main(String[] args) {
     test("AAA", "BBB", "CCC");    //可变长，最后都会被自动封装成一个数组
}
    
private static void test(String... test){
     System.out.println(test[0]);    //其实参数就是一个数组
}

由于是数组，所以说只能使用一种类型的可变长参数，并且可变长参数只能放在最后一位！

5.封装、继承、多态

封装、继承、多态 是面向对象编程的三大特性。

5.1 封装

封装的目的是为了保证变量的安全性，使用者不必在意具体实现细节，而只是通过外部接口即可访问类的成员，如果不进行封装，类中的实例变量可以直接查看和修改，可能给整个代码带来不好的影响，因此在编写类时 一般将成员变量私有化，外部类需要同 getter 和 setter 方法来查看和设置变量。

设想：学生小明已经创建成功，正常情况下能随便改他的名字和年龄吗？

public class Student {
    private String name;
    private int age;
  
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }
}

也就是说，外部现在只能通过调用我定义的方法来获取成员属性，而我们可以在这个方法中进行一些额外的操作，比如小明可以修改名字，但是名字中不能包含 “小” 这个字。

public void setName(String name) {
    if(name.contains("小")) return;
    this.name = name;
}

单独给外部开放设置名称的方法，因为我 还需要做一些额外的处理，所以说不能给外部直接操作成员变量的权限！

封装思想其实就是把实现细节给隐藏了，外部只需知道这个方法是什么作用，而无需关心实现。封装就是通过访问权限控制来实现的。

5.2 继承

继承属于非常重要的内容，在定义不同类的时候存在一些相同属性，为了方便使用可以将这些共同属性抽象成一个父类，在定义其他子类时可以继承自该父类，减少代码的重复定义，子类可以使用父类中非私有的成员。

现在学生分为两种，艺术生和体育生，他们都是学生的分支，但是他们都有自己的方法：

public class SportsStudent extends Student{   //通过extends关键字来继承父类

    public SportsStudent(String name, int age) {
        super(name, age);   // 必须先通过 super 关键字（指代父类），实现父类的构造方法！
    }

    public void exercise(){
        System.out.println("我超勇的！");
    }
}

public class ArtStudent extends Student{

    public ArtStudent(String name, int age) {
        super(name, age);
    }

    public void art(){
        System.out.println("随手画个毕加索！");
    }
}

子类具有父类的全部属性，protected 可见但外部无法使用（包括 private 属性，不可见，无法使用），同时子类还能有自己的方法。继承只能继承一个父类，不支持多继承！

每一个子类必须定义一个实现父类构造方法的构造方法，也就是需要在构造方法开始使用 super()，如果父类使用的是默认构造方法，那么子类不用手动指明。

所有类都默认继承自 Object 类，除非手动指定类型，但是依然改变不了最顶层的父类是 Object 类。所有类都包含 Object 类中的方法。

5.3 多态

多态是同一个行为具有多个不同表现形式或形态的能力。也就是同样的方法，由于实现类不同，执行的结果也不同！

方法的重写和重载是不一样的，重载是原有的方法逻辑不变的情况下，支持更多参数的实现，而重写是直接覆盖原有方法！

// 父类中的 study
public void study(){
    System.out.println("学习");
}

// 子类中的 study
@Override  //声明这个方法是重写的，但是可以不要，我们现阶段不接触
public void study(){
    System.out.println("给你看点好康的");
}

再次定义同样的方法后，父类的方法就被覆盖！子类还可以给父类方法提升访问权限！

当我们在重写方法时，不仅想使用我们自己的逻辑，同时还希望执行父类的逻辑（也就是调用父类的方法）怎么办呢？

public void study(){
    super.study();
    System.out.println("给你看点好康的");
}

同理，如果想访问父类的成员变量，也可以使用 super 关键字来访问，注意，子类可以具有和父类相同的成员变量！而在方法中访问的默认是：形参列表中 > 当前类的成员变量 > 父类成员变量。

public void setTest(int test){
    test = 1;
  	this.test = 1;
  	super.test = 1;
}

我们曾经学习过基本数据类型的类型转换，支持一种数据类型转换为另一种数据类型，而我们的类也是支持类型转换的（仅限于存在亲缘关系的类之间进行转换）比如子类可以直接向上转型：

Student student = new SportsStudent("lbw", 20);  // 父类变量引用子类实例
student.study();     // 得到依然是具体实现的结果，而不是当前类型的结果

我们也可以把已经明确是由哪个类实现的父类引用，强制转换为对应的类型：

Student student = new SportsStudent("lbw", 20);  // 是由 SportsStudent 进行实现的
// ... do something...

SportsStudent ps = (SportsStudent)student;  // 让它变成一个具体的子类
ps.sport();  // 调用具体实现类的方法

这样的类型转换称为向下转型。

如果我们只是得到一个父类引用，但是不知道它到底是哪一个子类的实现怎么办？我们可以使用 instanceof 关键字来实现，它能够进行类型判断！

private static void test(Student student){
    if (student instanceof SportsStudent){
        SportsStudent sportsStudent = (SportsStudent) student;
        sportsStudent.sport();
    }else if (student instanceof ArtStudent){
        ArtStudent artStudent = (ArtStudent) student;
        artStudent.art();
    }
}

通过进行类型判断，我们就可以明确类的具体实现到底是哪个类！

我们目前只知道 final 关键字能够使得一个变量的值不可更改，那么如果在类前面声明 final，会发生什么？

public final class Student {   // 类被声明为终态，那么它还能被继承吗
  	
}

类一旦被声明为终态，将无法再被继承，不允许子类的存在！

public final void study(){  // 还能重写吗
    System.out.println("学习");
}

如果类的成员属性被声明为 final，那么必须在构造方法中或是在定义时赋初始值！

private final String name;   // 引用类型不允许再指向其他对象
private final int age;    // 基本类型值不允许发生改变

public Student(String name, int age) {
    this.name = name;
    this.age = age;
}

我们推荐在不会再发生改变的成员属性上添加 final 关键字，JVM 会对添加了 final 关键字的属性进行优化！

类本身就是一种抽象，而 抽象类，把类还要抽象，也就是说，抽象类可以只保留特征，而不保留具体呈现形态，比如方法可以定义好，但是我可以不去实现它，而是交由子类来进行实现！

public abstract class Student {       // 抽象类
	public abstract void test();  // 抽象方法
}

通过使用 abstract 关键字来表明一个类是一个抽象类，抽象类可以使用 abstract 关键字来表明一个方法为抽象方法，也可以定义普通方法，抽象方法不需要编写具体实现（无方法体）但是必须由子类实现（除非子类也是一个抽象类）！

抽象类由于不是具体的类定义，因此无法直接通过 new 关键字来创建对象！

Student s = new Student(){    //只能直接创建带实现的匿名内部类！
	public void test(){
    
	}
}

因此，抽象类一般只用作继承使用！抽象类使得继承关系之间更加明确。更加明确了多态的定义！同一个方法多种实现！

// 现在只能由子类编写，父类没有定义，更加明确了多态的定义！同一个方法多种实现！
public void study(){   
	System.out.println("给你看点好康的");
}

接口甚至比抽象类还抽象，它只代表某个确切的功能！也就是只包含方法的定义，甚至都不是一个类！接口包含了一些方法的具体定义，类可以实现这个接口，表示类支持接口代表的功能（类似于一个插件，只能作为一个附属功能加在主体上，同时具体实现还需要由主体来实现）。

public interface Eat {
	void eat(); 
}

通过使用 interface 关键字来表明是一个接口（注意，这里 class 关键字被替换为了 interface）接口只能包含 public 权限的抽象方法！（Java8 以后可以有默认实现）我们可以通过声明 default 关键字来给抽象方法一个默认实现。

public interface Eat {
    default void eat(){
        // do something...
    }
}

接口中定义的变量，默认为 public static final。

public interface Eat {
    int a = 1;
    void eat();
}

一个类可以实现很多个接口，但是不能理解为多继承！（实际上实现接口是附加功能，和继承的概念有一定出入，顶多说是多继承的一种替代方案）一个类可以附加很多个功能！

public class SportsStudent extends Student implements Eat, ...{
	@Override
    public void eat() {
        
    }
}

类通过 implements 关键字来声明实现的接口！每个接口之间用逗号隔开！

实现接口的类也能通过 instanceof 关键字判断，也支持向上和向下转型！

6.内部类

类中可以存在一个类！各种各样的长相怪异的代码就是从这里开始出现的！

6.1 成员内部类

我们的类中可以在嵌套一个类：

public class Test {
    class Inner{   // 类中定义的一个内部类
        
    }
}

成员内部类和成员变量和成员方法一样，都是属于对象的，也就是说，必须存在外部对象，才能创建内部类的对象！

public static void main(String[] args) {
    Test test = new Test();
    Test.Inner inner = test.new Inner();   //写法有那么一丝怪异，但是没毛病！
}

6.2 静态内部类

静态内部类其实就和类中的静态变量和静态方法一样，是属于类拥有的，我们可以直接通过 类名. 去访问。

public class Test {
    static class Inner{

    }
}

public static void main(String[] args) {
    Test.Inner inner = new Test.Inner();   //b不用再创建外部类对象了！
}

6.3 局部内部类

对，你没猜错，就是和局部变量一样哒 ~

public class Test {
    public void test(){
        class Inner{

        }
        
        Inner inner = new Inner();
    }
}

6.4 匿名内部类

匿名内部类才是我们的重点，也是实现 lambda 表达式的原理！匿名内部类其实就是在 new 的时候，直接对接口或是抽象类的实现。

public static void main(String[] args) {
        Eat eat = new Eat() {
            @Override
            public void eat() {
                //DO something...
            }
        };
    }

我们不用单独去创建一个类来实现，而是可以直接在 new 的时候写对应的实现！但是，这样写，无法实现复用，只能在这里使用！

lambda 表达式：读作 λ 表达式，它其实就是我们接口匿名实现的简化。

public static void main(String[] args) {
        Eat eat = new Eat() {
            @Override
            public void eat() {
                // DO something...
            }
        };
    }

public static void main(String[] args) {
        Eat eat = () -> {};   //等价于上述内容
    }

lambda 表达式（匿名内部类）只能访问外部的 final 类型或是隐式 final 类型的局部变量！

7.枚举类

假设现在我们想给小明添加一个状态（跑步、学习、睡觉），外部可以实时获取小明的状态：

public class Student {
    private final String name;
    private final int age;
    private String status;
  
  	//...
  
  	public void setStatus(String status) {
        this.status = status;
    }

    public String getStatus() {
        return status;
    }
}

但是这样会出现一个问题，如果我们仅仅是存储字符串，似乎外部可以不按照我们规则，传入一些其他的字符串。这显然是不够严谨的！

有没有一种办法，能够更好地去实现这样的状态标记呢？我们希望开发者拿到使用的就是我们定义好的状态，我们可以使用枚举类！

public enum Status {
    RUNNING, STUDY, SLEEP    // 直接写每个状态的名字即可，分号可以不打，但是推荐打上
}

使用枚举类也非常方便，我们只需要直接访问即可。

// Student.java
public class Student {
    private final String name;
    private final int age;
    private Status status;

    public Student(String name, int age){
        this.name = name;
        this.age = age;
    }

    public void setStatus(Status status) {   //不再是 String，而是我们指定的枚举类型
        this.status = status;
    }

    public Status getStatus() {
        return status;
    }
}

public class Main {
    public static void main(String[] args) {
        Student student = new Student("小明", 18);
        student.setStatus(Status.RUNNING);
        System.out.println(student.getStatus());
    }
}

枚举类型使用起来就非常方便了，其实枚举类型的本质就是一个普通的类，但是它继承自 Enum 类，我们定义的每一个状态其实就是一个 public static final 的 Status 类型成员变量！

// Compiled from "Status.java"
public final class com.test.Status extends java.lang.Enum<com.test.Status> {
	public static final com.test.Status RUNNING;
	public static final com.test.Status STUDY;
	public static final com.test.Status SLEEP;
	public static com.test.Status[] values();
	public static com.test.Status valueOf(java.lang.String);
	static {};
}

既然枚举类型是普通的类，那么我们也可以给枚举类型添加独有的成员方法。

// Status.java
public enum Status {
    RUNNING("运动"), STUDY("学习"), SLEEP("睡觉");   //无参构造方法被覆盖，创建枚举需要添加参数（本质就是调用的构造方法！）

    private final String name;    //枚举的成员变量
    Status(String name){    //覆盖原有构造方法（默认 private，只能内部使用！）
        this.name = name;
    }

    public String getName() {   //获取封装的成员变量
        return name;
    }
}

// Main.java
public class Main {
    public static void main(String[] args) {
        Student student = new Student("小明", 18);
        student.setStatus(Status.RUNNING);
        System.out.println(student.getStatus().getName());
    }
}

在这里插入图片描述
枚举类还自带一些继承下来的实用方法。

Status.valueOf("")   //将名称相同的字符串转换为枚举
Status.values()      //快速获取所有的枚举

8.基本类型包装类

Java 并不是纯面向对象的语言，虽然 Java 语言是一个面向对象的语言，但是 Java 中的基本数据类型却不是面向对象的。在学习泛型和集合之前，基本类型的包装类是一定要讲解的内容！

我们的基本类型，如果想通过对象的形式去使用他们，Java 提供的基本类型包装类，使得 Java 能够更好的体现面向对象的思想，同时也使得基本类型能够支持对象操作！

在这里插入图片描述

包装类实际上就行将我们的基本数据类型，封装成一个类（运用了封装的思想）。自动装箱和拆箱。

private final int value;   // Integer内部其实本质还是存了一个基本类型的数据，但是我们不能直接操作

public Integer(int value) {
    this.value = value;
}

现在我们操作的就是 Integer 对象，而不是一个 int 基本类型了！

public static void main(String[] args) {
     Integer i = 1;   // 包装类型可以直接接收对应类型的数据，并变为一个对象！
     System.out.println(i + i);    //包装类型可以直接被当做一个基本类型进行操作！
}

那么为什么包装类型能直接使用一个具体值来赋值呢？其实依靠的是自动装箱和拆箱机制。

Integer i = 1;    //其实这里只是简写了而已
Integer i = Integer.valueOf(1);  //编译后真正的样子

调用 valueOf 来生成一个 Integer 对象！

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)   //注意，Java为了优化，有一个缓存机制，如果是在-128~127之间的数，会直接使用已经缓存好的对象，而不是再去创建新的！（面试常考）
       return IntegerCache.cache[i + (-IntegerCache.low)];
  	return new Integer(i);   //返回一个新创建好的对象
}

而如果使用包装类来进行运算，或是赋值给一个基本类型变量，会进行 自动拆箱：

public static void main(String[] args) {
    Integer i = Integer.valueOf(1);
    int a = i;    //简写
    int a = i.intValue();   //编译后实际的代码
  
  	long c = i.longValue();   //其他类型也有！
}

既然现在是包装类型了，那么我们还能使用 == 来判断两个数是否相等吗？

public static void main(String[] args) {
    Integer i1 = 28914;
    Integer i2 = 28914;

    System.out.println(i1 == i2);   // 实际上判断是两个对象是否为同一个对象（内存地址是否相同）
    System.out.println(i1.equals(i2));   // 这个才是真正的值判断！
}

在这里插入图片描述

注意 IntegerCache 带来的影响！

思考：下面这种情况结果会是什么？

public static void main(String[] args) {
    Integer i1 = 28914;
    Integer i2 = 28914;

    System.out.println(i1+1 == i2+1);
}

在这里插入图片描述
在集合类的学习中，我们还会继续用到我们的包装类型！

9.面向对象编程实战

设计一个 Person 抽象类，包含吃饭、运动、学习三种行为，分为工人、学生、老师三种职业。
设计一个接口：考试，只有老师和学生会考试。
设计一个方法，模拟让人类进入考场，要求只有会考试的人才能进入，并且考试。

在这里插入图片描述

// Person.java
package person;

public abstract class Person {
    public abstract void eat();
    public abstract void run();
    public abstract void study();
}

// Worker.java
package person;

public class Worker extends Person {
    @Override
    public void eat() {

    }

    @Override
    public void run() {

    }

    @Override
    public void study() {

    }
}

// Student.java
package person;

public class Student extends Person implements Exam {
    @Override
    public void eat() {

    }

    @Override
    public void run() {

    }

    @Override
    public void study() {

    }

    @Override
    public void exam() {

    }
}

// Teacher.java
package person;

public class Teacher extends Person implements Exam {
    @Override
    public void eat() {

    }

    @Override
    public void run() {

    }

    @Override
    public void study() {

    }

    @Override
    public void exam() {

    }
}

// Exam.java 接口
package person;

public interface Exam {
    void exam();
}

// Main.java
import person.Exam;
import person.Person;


public class Main {
    public static void main(String[] args) {

    }

    private static void test(Person person){
        if (person instanceof Exam){
            Exam e = (Exam) person; // 强制类型转换
            e.exam();
        }
    }
}

如果需要给 Person 类添加一些其他的属性，其子类要记得实现构造方法。

package person;

public abstract class Person {

    private String name;
    
    public Person(String name) {
        this.name = name;
    }
    
    public abstract void eat();
    public abstract void run();
    public abstract void study();
}

package person;

public class Worker extends Person {
    public Worker(String name) {
        super(name);
    }

    @Override
    public void eat() {

    }

    @Override
    public void run() {

    }

    @Override
    public void study() {

    }
}

敬请期待后续更新！

G皮T

关注

3
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
【Java编程】JavaSE基础总结（二）：面向对象

对象基于类创建，类相当于一个模板，对象就是根据模板创建出来的实体（就像做月饼，我们要做一个月饼首先需要一个模具，模具就是我们的类，而做出来的月饼，就是类的实现，也叫做对象），类是抽象的数据类型，并不能代表某一个具体的事物，类是对象的一个模板。类具有自己的属性，包括成员变量、成员方法等，我们可以调用类的成员方法来让类进行一些操作。
复制链接

扫一扫