Java学习笔记-03

public class Phone {
    // 属性（成员属性）
    String brand; // 品牌
    double price; // 价格
    String color; // 颜色
    // 方法（成员方法）
    public void call() {
        System.out.println("手机都可以打电话");
    }
    public void sendMessage() {
        System.out.println("手机都可以发短信");
    }
}

对象

创建对象

类名对象名 = new 类名()；

使用成员属性和成员方法

对象名.成员属性对象名.成员方法

举例：

public class Phone {
    // 属性（成员属性）
    String brand; // 品牌
    double price; // 价格
    String color; // 颜色
    // 方法（成员方法）
    public void call() {
        System.out.println("手机都可以打电话");
    }
    public void sendMessage() {
        System.out.println("手机都可以发短信");
    }
    // 主方法，程序入口
    public static void main(String[] args) {
        // 实例化类，创建一个具体的对象
        Phone phone = new Phone();
        // 访问成员属性
        phone.brand = "华为";
        phone.price = 6999.00;
        phone.color = "远峰蓝";
        // 访问成员方法
        phone.call();
        phone.sendMessage();
    }
}

成员变量与局部变量的区别

成员变量：类中方法外的变量，就是成员变量
局部变量：类中方法内的变量，就是局部变量，参数也是局部变量

public class Phone {
    // 属性（成员属性,又叫成员变量）
    String brand; // 品牌
    double price; // 价格
    String color; // 颜色
    // 方法（成员方法）
    public void call() {
        String inner = "局部变量"; // 局部变量
        System.out.println("手机都可以打电话");
        System.out.println("变量声明在方法内，这是局部变量" + inner);
    }
    public void sendMessage(String msg) { // 参数也是局部变量
        System.out.println("手机都可以发短信,短信内容为" + msg);
    }
}

具体区别：

区别	成员变量	局部变量
类中位置不同	类中方法外	类中方法内
内存中位置不同	堆内存	栈内存
声明周期不同	随对象存在而存在，随对象消失而销毁	随方法调用而存在，随方法结束消失而消失
初始化值不同	有默认的初始化值	没有默认的初始化值，必须定义的时候赋值

修饰符private

是一个权限修饰符，表示私有的
可以修饰成员变量和成员方法
被private修饰的成员变量/方法，就只能在本类中进行使用。可以保护成员变/方法不被其他类使用

定义私有成员

修饰成员变量

private 数据类型成员变量名；

修饰成员方法

private 方法返回值类型成员方法名(参数...) { ... }

举例：

void表示方法没有返回值。如果方法需要有返回值，则void处就写对象的返回值类型即可

public class Phone {
    // 属性（成员属性,又叫成员变量）
    private String brand; // 品牌
    private double price; // 价格
    private String color; // 颜色
    // 方法（成员方法）
    private void call() {
        System.out.println("手机都可以打电话");
    }
}

访问private修饰的(访问私有变量)

如果在本类中，可以直接访问
如果是外部类，需要通过get和set进行访问

手机类

public class Phone {
    // 属性（成员属性,又叫成员变量）
    private String brand; // 品牌
    private double price; // 价格
    private String color; // 颜色
    // 方法（成员方法）
    private void call() {
        System.out.println(brand + "手机都可以打电话"); // 华为手机都可以打电话
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

手机测试类

public class Main {
    public static void main(String[] args) {
        // 实例化类
        Phone phone = new Phone();
        // 通过set方法，给成员变量赋值
        phone.setBrand("华为");
        // 通过get方法，获取成员变量
        System.out.println(phone.getBrand()); // 华为
    }
}

Iead编辑器有快捷键可以生成get和set方法

首先我们在类中声明好成员变量

然后空白处点击鼠标右键，找到Generate点击

最后根据需要点击生成对应的即可

this关键字

我们只需要记住，谁调用，this就是谁
一般this用来访问本类中的属性，方法，构造器
this用于区分成员与局部
this只能在类定义的方法中使用，不能在类定义的外部使用

public class Phone {
    private String brand;
    private void call() {
        System.out.println(brand + "手机都可以打电话");
    }

    public String getBrand() {
        // 这里的brand表示当前类中的成员属性brand
        return brand;
    }

    public void setBrand(String brand) {
        // 这里的this就表示当前类的实例化的对象
        // this.brand 表示当前类中的成员属性brand（成员变量）
        // (如果参数没有与brand重名，则可以省略this，也表示当前类中的成员属性brand。可以看下getBrand方法)
        // brand 则表示传入的参数brand（局部变量）
        this.brand = brand;
    }
}

访问成员变量

this.成员变量名

访问构造函数(先了解)

this(参数列表)

只能在构造器中使用(意思就是只能在构造器中访问另外一个构造器)
并且必须放在构造函数的第一条语句上，顶置

构造函数

构造函数分为有参构造函数和无参构造函数
如果不写，则会默认内置一个无参构造函数
如果写了有参构造函数，则不会默认提供无参构造函数，也就是说，要补一个无参构造函数
构造函数的方法名要与类名一致
作用：创建对象时，可以完成对成员属性的初始化(其实就是完成对数据的初始化)
实例化对象时，会先执行构造函数
如果实例化对象时，没有传入参数，则会调用无参构造函数，如果实例化对象时，传入了参数，则会调用有参构造函数

人类

package Person;

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    private Person() {
        System.out.println("我是无参构造函数");
    }

    public Person(String name, int age) {
        // 可以对传入的参数进行下简单的判断
        if (age > 120 | age < 0) {
            System.out.println("您输入的年龄有误");
        } else {
            this.name = name;
            this.age = age;
        }
    }
}

人类测试类

import Person.Person;

public class Main {
    public static void main(String[] args) {
        Person zs  = new Person("张三", -1); // 您输入的年龄有误
    }
}

修改成员变量的方式有两种

通过set方法进行修改，可以在其中进行一些简单的判断
也可以通过有参构造函数进行修改，也可以在其中进行一些简单的判断

继承

每个类只能继承一个父类
但是可以多层继承(爷 -> 父 -> 孙 -> 重孙...)
继承可以使子类具有父类的属性和方法，还可以在子类中声明自己的成员，对父类进行扩充
父类又称为超类，基类。子类又称派生类
子类中所有的构造方法，默认都会访问父类中的无参构造方法。先有父再有子
每个子类构造方法的第一句默认都是super() ，如果无参，则是super()，如果有参，则super(参数...)
this() 表示调用本类的无参构造方法
super() 表示调用父类的无参构造方法

public class 子类 extends 父类 { ...... }

父类

package Person;

public class Father {
    private String name;
    private String age;

    public void doBusiness() {
        System.out.println("做生意的");
    }

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public Father() {
        System.out.println("父类的无参构造函数");
    }

    public Father(String name, String age) {
        System.out.println("父类的有参构造函数");
        this.name = name;
        this.age = age;
    }
}

子类

package Person;

public class Son extends Father {
    // 继承了父类，则可以直接使用父类的东西
    public Son() {
        super(); // 这个不用写，默认就内置了
        System.out.println("子类的无参构造方法");
    }

    public Son(String name, String age) {
        super(name, age);
        System.out.println("子类的有参构造方法");
    }
}

测试类

import Person.Son;

public class Main {
    public static void main(String[] args) {
        Son s = new Son(); // 父类的无参构造函数(会先执行父类的无参构造函数)  子类的无参构造方法
        s.doBusiness(); // 做生意的
    }
}

this与super

this表示本类对象的引用
super表示父类存储空间的标识（可以理解为父类对象的引用）

	访问成员变量	访问成员方法	访问构造函数
this	this.xxx	this.xx()	this() / this(参数...)
super	super.xxx	super.xx()	super() / super(参数...)

子类访问构造的顺序

如果子类实例化无参父类无参 --> 子类无参
如果子类实例化有参父类有参 --> 子类无参

父类子类跟上面一样

测试类

import Person.Son;

public class Main {
    public static void main(String[] args) {
        new Son(); // 父类的无参构造函数  子类的无参构造方法
        new Son("张三","41"); // 父类的有参构造函数  子类的有参构造方法
    }
}

子类方法重写

子类如果不满足父类的方法，也可以对父类中的方法进行重写或者补充
但是重写的方法，方法名和参数列表都需要跟父类的一致
重写需要添加 @Override 关键字，可以对重写进行检查
私有方法是不可以重写的，因为子类不会继承到父类的私有方法，所以更不可能重写.
子类方法的访问权限(public > default > private)，不能比父类低

父类

package Person;

public class Father {
    public void doBusiness() {
        System.out.println("做生意的");
    }
}

子类

package Person;

public class Son extends Father {
    // 方法重写
    @Override
    public void doBusiness() {
        super.doBusiness();
        System.out.println("子类可以重写父类中的方法，也可以在原方法上进行扩展");
    }
}

测试类

import Person.Son;

public class Main {
    public static void main(String[] args) {
        Son son = new Son();
        son.doBusiness(); // 做生意的
    }
}

权限修饰符

可以修饰方法，属性，类。一般都是放在最前面的
权限修饰符一共有4个，分别是(从大到小)：public，protected，defaule，private

权限修饰符	同一个类	同一个包	不同包的子类	不同包的非子类
private	√	×	×	×
default	√	√	×	×
protected	√	√	√（只有继承的，在不同包下才可以访问）	×
public	√	√	√	√

private

被private修饰的，都是私有成员。只能在本类中才能进行访问

package Person;

public class Father {
    // 私有成员属性
    private int num = 100;
    // 私有的，只能在本类中进行使用
    public void readPrivate() {
        System.out.println("私有变量只能在本类中进行访问：" + num);
    }
}

default

不写权限修饰符，默认就是这个。只能在本类和同一个包下的类进行使用

类A（Person包下）

package Person;

public class Father {
    // 私有成员属性
     int num = 100;
    // 私有的，只能在本类中进行使用
    public void readPrivate() {
        System.out.println("默认变量可以在本类中进行访问：" + num);
    }
}

类B（Person包下）

package Person;

public class Son {
    public static void main(String[] args) {
        Father father = new Father();
        father.readPrivate();
        father.num = 10;
        System.out.println(father.num);
    }
}

protected

受保护的，只能在本类中，同一个包下，如果不同包，但是有继承关系，这几种情况使用

类A（Person包下）

package Person;

public class Father {
    // 受保护的成员属性
     protected int num = 100;
    // 可以在本类中进行使用
    public void readPrivate() {
        System.out.println("受保护成员变量可以在本类中进行访问：" + num);
    }
}

类B（Person包下）

package Person;

public class Son {
    public static void main(String[] args) {
        Father father = new Father();
        father.readPrivate();
        // 同一个包下，受保护的成员也可以使用
        father.num = 10;
        System.out.println(father.num);
    }
}

类C（Demo包下）

package Demo;

import Person.Father;

public class Demo extends Father {
    public void print() {
        System.out.println("父类的受保护成员变量为" + super.num);
    }
}

测试类（Demo包下）

package Demo;

import Person.Father;

public class PersonTest {
    public static void main(String[] args) {
        // 1. 不同包下
        Father father = new Father();
        // 如果没有继承关系，是访问不了受保护的成员的
        // father.num  编译会直接报错
        // 2. 不同包下，但是有继承关系
        Demo demo = new Demo();
        demo.print();
    }
}

public

都可以直接进行使用，权限放开

注意事项

父类protected修饰的方法，子类对象是不能直接调用的，需要子类进行重写后(并且修饰符要改为public)，子类才能调用

父类默认权限符修饰的方法，子类对象也是不能直接调用的，需要子类进行重写后(并且修饰符要改为public)，子类才能调用

父类（Demo包下）

package Demo;

public class Father {
    public void a() {
        System.out.println("public");
    }
    protected void a1() {
        System.out.println("protected");
    }
    void a2() {
        System.out.println("default");
    }
}

子类（Demo包下）

package Demo;

public class Son extends Father {
    @Override
    public void a1() {
        super.a1();
    }

    @Override
    public void a2() {
        super.a2();
    }
}

测试类（Demo包下）

import Demo.Son;

public class Main {
    public static void main(String[] args) {
        Son s = new Son();
        // 可以直接调用public
        s.a(); // public
        // 父类protected修饰的方法，子类对象是不能直接调用的，需要子类进行重写后(并且修饰符要改为public)，子类才能调用
        s.a1(); // protected
        // 父类默认权限符修饰的方法，子类对象也是不能直接调用的，需要子类进行重写后(并且修饰符要改为public)，子类才能调用
        s.a2(); // default
    }
}

包package

包其实就是文件夹，作用就是对类进行分类管理

package 包名；

多级包，则用 . 进行分开

package 一级.二级....

举例：

package com.Xxx.xx

就是创建了一个com的文件下，里面有Xxx文件夹，Xxx文件夹下有一个xx的文件夹

类的名称

类完整名称 = 包的名称 + 类的名称保障类名唯一，不允许重复

举例：

com.minsheng.day01

在此包下创建一个Demo的类，则此类的完整名称就是 com.minsheng.day01.Demo

导包

import com.minsheng.day01.* // 导入所有
import com.minsheng.day01.xxx // 导入具体的单一的类

如果在同一个包下，默认情况下，不需要写import

状态修饰符final

final（最终态），可修饰类，成员变量，成员方法
被final关键字修饰的类，无法被继承
被final关键字修饰的成员方法，可以被继承，但是无法被重写
被final关键字修饰的成员变量，是无法被修改的，并且必须赋初始值。常量名称一般都大写

父类

// 被final修饰的类，是无法被继承的
public class Demo {
    // 被final修饰的成员变量，是不能改变的，并且必须赋初始值。也是不能被继承的
    private final int SUCCESSCODE = 200;
    // 被final修饰的成员方法，可以被继承，但是无法被重写
    public final void print() {
        System.out.println("被final修饰的成员方法，是无法被重写的");
    }
}

子类

public class Test extends Demo {
    public void fn() {
        super.print();
    }
}

测试类

public class Main {
    public static void main(String[] args) {
        new Test().fn();
    }
}

final还可以修饰局部变量

修饰基本数据类型：不能被修改，必须赋初始值

public class Demo {
    public void print() {
        // final修饰局部变量，这个局部变量就不可以被修改了，并且必须赋初始值
        final int age = 24;
        // age = 20; // Cannot assign a value to final variable 'age'
    }
}

修饰复杂(又叫引用)数据类型：栈内存地址不能够发生改变，但是引用数据类型的内存地址里面的成员属性值是可以变化的

类A

public class Demo {
    int age = 24;
}

测试类

public class Main {
    public static void main(String[] args) {
        // 被final修饰的复杂数据类型，内存地址不可以变，但是里面的成员变量可以改变
        final Demo demo = new Demo();
        // 改变成员变量
        demo.age = 18;
        System.out.println(demo.age);
    }
}

原文链接：https://blog.csdn.net/qq_52845451/article/details/130462731

最后修改：2023 年 10 月 30 日

如果觉得我的文章对你有用，请随意赞赏

此处评论已关闭

Java学习笔记-03

Atigger • 2023 年 10 月 30 日

<div id="content_views" class="htmledit_views">目录<a href="#%E7%B1%BB%E4%B8%8E%E5%AF%B9%E8%B1%A1">类与对象</a><a href="#%E7%B1%BBclass">类class</a><a href="#%E5%AF%B9%E8%B1%A1">对象</a><a href="#%E8%AE%BF%E9%97%AE%E4%BF%AE%E9%A5%B0%E7%AC%A6">修饰符private</a><a href="#%C2%A0this%E5%85%B3%E9%94%AE%E5%AD%97">&nbsp;this关键字</a><a href="#%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0">构造函数</a><a href="#%E7%BB%A7%E6%89%BF">继承</a><a href="#%E6%9D%83%E9%99%90%E4%BF%AE%E9%A5%B0%E7%AC%A6">权限修饰符</a><a href="#%E5%8C%85package">包package</a><a href="#%E7%8A%B6%E6%80%81%E4%BF%AE%E9%A5%B0%E7%AC%A6">状态修饰符final</a><hr id="hr-toc"><h4 id="%E7%B1%BB%E4%B8%8E%E5%AF%B9%E8%B1%A1">类与对象</h4>&nbsp;类<ul>
 <li>类是对现实生活中一类事物的抽象，里面包含了这类事物共有的属性(名词)和行为(动词)</li>
 <li>例如人类，人就是一个大类，每个人都应该有名字，年龄，性别，身高，体重(这些都是属性)...，当然每个人还可以说话，走路，跑步(这些都是行为)...</li>
 </ul>对象<ul>
 <li>而对象则是看得见，摸得着，实实在在的实体</li>
 <li>实例化类，就可以得到一个具体的对象</li>
 </ul>类与对象的关系<ul>
 <li>类是对象的抽象，对象是类的实体</li>
 <li>一个类可以实例化n多个对象</li>
 </ul>简单理解：类是对事物的一种描述，对象则是具体存在的事物<h4 id="%E7%B1%BBclass">类class</h4><ul>
 <li>类是Java程序的基本组成单位</li>
 <li>类是具有相同属性和行为的一组对象的集合</li>
 <li>属性：类中方法外的变量(类中通过成员变量来体现)</li>
 <li>行为：类中的方法</li>
 </ul>举例：定义一个手机类<ul>
 <li>成员：表示类中的成员，可以是成员属性，也可以是成员方法</li>
 <li>成员属性可以不用赋值，默认系统会赋一个默认值</li>
 </ul><pre><code class="language-java">public class Phone {
 // 属性（成员属性）
 String brand; // 品牌
 double price; // 价格
 String color; // 颜色
 // 方法（成员方法）
 public void call() {
 System.out.println("手机都可以打电话");
 }
 public void sendMessage() {
 System.out.println("手机都可以发短信");
 }
}
</code></pre><h4 id="%E5%AF%B9%E8%B1%A1">对象</h4>创建对象<blockquote>类名&nbsp; 对象名&nbsp; =&nbsp; new&nbsp; 类名()；</blockquote>使用成员属性和成员方法<blockquote>对象名.成员属性&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 对象名.成员方法</blockquote>举例：<pre><code class="language-java">public class Phone {
 // 属性（成员属性）
 String brand; // 品牌
 double price; // 价格
 String color; // 颜色
 // 方法（成员方法）
 public void call() {
 System.out.println("手机都可以打电话");
 }
 public void sendMessage() {
 System.out.println("手机都可以发短信");
 }
 // 主方法，程序入口
 public static void main(String[] args) {
 // 实例化类，创建一个具体的对象
 Phone phone = new Phone();
 // 访问成员属性
 phone.brand = "华为";
 phone.price = 6999.00;
 phone.color = "远峰蓝";
 // 访问成员方法
 phone.call();
 phone.sendMessage();
 }
}
</code></pre>成员变量与局部变量的区别<ul>
 <li>成员变量：类中方法外的变量，就是成员变量</li>
 <li>局部变量：类中方法内的变量，就是局部变量，参数也是局部变量</li>
 </ul><pre><code class="language-java">public class Phone {
 // 属性（成员属性,又叫成员变量）
 String brand; // 品牌
 double price; // 价格
 String color; // 颜色
 // 方法（成员方法）
 public void call() {
 String inner = "局部变量"; // 局部变量
 System.out.println("手机都可以打电话");
 System.out.println("变量声明在方法内，这是局部变量" + inner);
 }
 public void sendMessage(String msg) { // 参数也是局部变量
 System.out.println("手机都可以发短信,短信内容为" + msg);
 }
}
</code></pre>具体区别：<table border="1" cellpadding="1" cellspacing="1">
 <tbody>
 <tr>
 <td>区别</td>
 <td>成员变量</td>
 <td>局部变量</td>
 </tr>
 <tr>
 <td>类中位置不同</td>
 <td>类中方法外</td>
 <td>类中方法内</td>
 </tr>
 <tr>
 <td>内存中位置不同</td>
 <td>堆内存</td>
 <td>栈内存</td>
 </tr>
 <tr>
 <td>声明周期不同</td>
 <td>随对象存在而存在，随对象消失而销毁</td>
 <td>随方法调用而存在，随方法结束消失而消失</td>
 </tr>
 <tr>
 <td>初始化值不同</td>
 <td>有默认的初始化值</td>
 <td>没有默认的初始化值，必须定义的时候赋值</td>
 </tr>
 </tbody>
 </table><h4 id="%E8%AE%BF%E9%97%AE%E4%BF%AE%E9%A5%B0%E7%AC%A6">修饰符private</h4><ul>
 <li>是一个权限修饰符，表示私有的</li>
 <li>可以修饰成员变量和成员方法</li>
 <li>被private修饰的成员变量/方法，就只能在本类中进行使用。可以保护成员变/方法不被其他类使用</li>
 </ul>定义私有成员修饰成员变量<blockquote>private&nbsp; 数据类型&nbsp; 成员变量名；</blockquote>修饰成员方法<blockquote>private&nbsp; 方法返回值类型&nbsp;成员方法名(参数...) { ... }</blockquote>举例：<ul>
 <li>void表示方法没有返回值。如果方法需要有返回值，则void处就写对象的返回值类型即可</li>
 </ul><pre><code class="language-java">public class Phone {
 // 属性（成员属性,又叫成员变量）
 private String brand; // 品牌
 private double price; // 价格
 private String color; // 颜色
 // 方法（成员方法）
 private void call() {
 System.out.println("手机都可以打电话");
 }
}
</code></pre>访问private修饰的(访问私有变量)<ul>
 <li>如果在本类中，可以直接访问</li>
 <li>如果是外部类，需要通过get和set进行访问</li>
 </ul>手机类<pre><code class="language-java">public class Phone {
 // 属性（成员属性,又叫成员变量）
 private String brand; // 品牌
 private double price; // 价格
 private String color; // 颜色
 // 方法（成员方法）
 private void call() {
 System.out.println(brand + "手机都可以打电话"); // 华为手机都可以打电话
 }

public String getBrand() {
        return brand;
    }

public void setBrand(String brand) {
        this.brand = brand;
    }

public double getPrice() {
        return price;
    }

public void setPrice(double price) {
        this.price = price;
    }

public String getColor() {
        return color;
    }

public void setColor(String color) {
 this.color = color;
 }
}
</code></pre>手机测试类<pre><code class="language-java">public class Main {
 public static void main(String[] args) {
 // 实例化类
 Phone phone = new Phone();
 // 通过set方法，给成员变量赋值
 phone.setBrand("华为");
 // 通过get方法，获取成员变量
 System.out.println(phone.getBrand()); // 华为
 }
}</code></pre>Iead编辑器有快捷键可以生成get和set方法<ul>
 <li>首先我们在类中声明好成员变量</li>
 </ul><img alt="" height="482" src="https://img-blog.csdnimg.cn/ff5f9155e911445bbb8c49c663c692d4.png" width="795"><ul>
 <li>&nbsp;然后空白处点击鼠标右键，找到Generate点击</li>
 </ul><img alt="" height="814" src="https://img-blog.csdnimg.cn/22be3df2943c49669cfea6cb64389d5e.png" width="1200"><ul>
 <li>&nbsp;最后根据需要点击生成对应的即可</li>
 </ul><img alt="" height="659" src="https://img-blog.csdnimg.cn/3ed2de038ec5462c98e8602b35d20fa9.png" width="1192"><h4 id="%C2%A0this%E5%85%B3%E9%94%AE%E5%AD%97">&nbsp;this关键字</h4><ul>
 <li>我们只需要记住，谁调用，this就是谁</li>
 <li>一般this用来访问本类中的属性，方法，构造器</li>
 <li>this用于区分 成员 与 局部</li>
 <li>this只能在类定义的方法中使用，不能在类定义的外部使用</li>
 </ul><pre><code class="language-java">public class Phone {
 private String brand;
 private void call() {
 System.out.println(brand + "手机都可以打电话");
 }

public String getBrand() {
        // 这里的brand表示当前类中的成员属性brand
        return brand;
    }

public void setBrand(String brand) {
 // 这里的this就表示当前类的实例化的对象
 // this.brand 表示当前类中的成员属性brand（成员变量）
 // (如果参数没有与brand重名，则可以省略this，也表示当前类中的成员属性brand。可以看下getBrand方法)
 // brand 则表示传入的参数brand（局部变量）
 this.brand = brand;
 }
}
</code></pre>访问成员变量<blockquote>this.成员变量名</blockquote>访问构造函数(先了解)<blockquote>this(参数列表)</blockquote><ul>
 <li>只能在构造器中使用(意思就是只能在构造器中访问另外一个构造器)</li>
 <li>并且必须放在构造函数的第一条语句上，顶置</li>
 </ul><h4 id="%E6%9E%84%E9%80%A0%E5%87%BD%E6%95%B0">构造函数</h4><ul>
 <li>构造函数分为有参构造函数和无参构造函数</li>
 <li>如果不写，则会默认内置一个无参构造函数</li>
 <li>如果写了有参构造函数，则不会默认提供无参构造函数，也就是说，要补一个无参构造函数</li>
 <li>构造函数的方法名要与类名一致</li>
 <li>作用：创建对象时，可以完成对成员属性的初始化(其实就是完成对数据的初始化)</li>
 <li>实例化对象时，会先执行构造函数</li>
 <li>如果实例化对象时，没有传入参数，则会调用无参构造函数，如果实例化对象时，传入了参数，则会调用有参构造函数</li>
 </ul>人类<pre><code class="language-java">package Person;

public class Person {
    private String name;
    private int age;

public String getName() {
        return name;
    }

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

public int getAge() {
        return age;
    }

public void setAge(int age) {
        this.age = age;
    }

private Person() {
        System.out.println("我是无参构造函数");
    }

public Person(String name, int age) {
 // 可以对传入的参数进行下简单的判断
 if (age &gt; 120 | age &lt; 0) {
 System.out.println("您输入的年龄有误");
 } else {
 this.name = name;
 this.age = age;
 }
 }
}
</code></pre>人类测试类<pre><code class="language-java">import Person.Person;

public class Main {
 public static void main(String[] args) {
 Person zs = new Person("张三", -1); // 您输入的年龄有误
 }
}</code></pre>修改成员变量的方式有两种<ol>
 <li>通过set方法进行修改，可以在其中进行一些简单的判断</li>
 <li>也可以通过有参构造函数进行修改，也可以在其中进行一些简单的判断</li>
 </ol><h4 id="%E7%BB%A7%E6%89%BF">继承</h4><ul>
 <li>每个类只能继承一个父类</li>
 <li>但是可以多层继承(爷 -&gt; 父 -&gt; 孙 -&gt; 重孙...)</li>
 <li>继承可以使子类具有父类的属性和方法，还可以在子类中声明自己的成员，对父类进行扩充</li>
 <li>父类又称为超类，基类。子类又称派生类</li>
 <li>子类中所有的构造方法，默认都会访问父类中的无参构造方法。先有父再有子</li>
 <li>每个子类构造方法的第一句默认都是super() ，如果无参，则是super()，如果有参，则super(参数...)</li>
 <li>this()&nbsp; 表示调用本类的无参构造方法</li>
 <li>super()&nbsp; 表示调用父类的无参构造方法</li>
 </ul><blockquote>public class 子类 extends 父类 { ...... }</blockquote>父类<pre><code class="language-java">package Person;

public class Father {
    private String name;
    private String age;

public void doBusiness() {
        System.out.println("做生意的");
    }

public String getName() {
        return name;
    }

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

public String getAge() {
        return age;
    }

public void setAge(String age) {
        this.age = age;
    }

public Father() {
        System.out.println("父类的无参构造函数");
    }

public Father(String name, String age) {
 System.out.println("父类的有参构造函数");
 this.name = name;
 this.age = age;
 }
}
</code></pre>子类<pre><code class="language-java">package Person;

public class Son extends Father {
    // 继承了父类，则可以直接使用父类的东西
    public Son() {
        super(); // 这个不用写，默认就内置了
        System.out.println("子类的无参构造方法");
    }

public Son(String name, String age) {
 super(name, age);
 System.out.println("子类的有参构造方法");
 }
}
</code></pre>测试类<pre><code class="language-java">import Person.Son;

public class Main {
 public static void main(String[] args) {
 Son s = new Son(); // 父类的无参构造函数(会先执行父类的无参构造函数) 子类的无参构造方法
 s.doBusiness(); // 做生意的
 }
}</code></pre>this与super<ul>
 <li>this表示本类对象的引用</li>
 <li>super表示父类存储空间的标识（可以理解为父类对象的引用）</li>
 </ul><table border="1" cellpadding="1" cellspacing="1" style="width:500px;">
 <tbody>
 <tr>
 <td></td>
 <td>访问成员变量</td>
 <td>访问成员方法</td>
 <td>访问构造函数</td>
 </tr>
 <tr>
 <td>this</td>
 <td>this.xxx</td>
 <td>this.xx()</td>
 <td>this()&nbsp; &nbsp; &nbsp;/&nbsp; &nbsp; this(参数...)</td>
 </tr>
 <tr>
 <td>super</td>
 <td>super.xxx</td>
 <td>super.xx()</td>
 <td>super()&nbsp; &nbsp; /&nbsp; &nbsp; super(参数...)</td>
 </tr>
 </tbody>
 </table>子类访问构造的顺序<ul>
 <li>如果子类实例化无参&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;父类无参&nbsp; &nbsp; --&gt;&nbsp; &nbsp; 子类无参</li>
 <li>如果子类实例化有参&nbsp; &nbsp; &nbsp; &nbsp; 父类有参&nbsp; &nbsp; --&gt;&nbsp; &nbsp; 子类无参</li>
 </ul>父类子类跟上面一样测试类<pre><code class="language-java">import Person.Son;

public class Main {
 public static void main(String[] args) {
 new Son(); // 父类的无参构造函数 子类的无参构造方法
 new Son("张三","41"); // 父类的有参构造函数 子类的有参构造方法
 }
}</code></pre>子类方法重写<ul>
 <li>子类如果不满足父类的方法，也可以对父类中的方法进行重写或者补充</li>
 <li>但是重写的方法，方法名和参数列表都需要跟父类的一致</li>
 <li>重写需要添加 @Override 关键字，可以对重写进行检查</li>
 <li>私有方法是不可以重写的，因为子类不会继承到父类的私有方法，所以更不可能重写.</li>
 <li>子类方法的访问权限(public &gt; default &gt; private)，不能比父类低</li>
 </ul>父类<pre><code class="language-java">package Person;

public class Father {
 public void doBusiness() {
 System.out.println("做生意的");
 }
}
</code></pre>子类<pre><code class="language-java">package Person;

public class Son extends Father {
 // 方法重写
 @Override
 public void doBusiness() {
 super.doBusiness();
 System.out.println("子类可以重写父类中的方法，也可以在原方法上进行扩展");
 }
}
</code></pre>测试类<pre><code class="language-java">import Person.Son;

public class Main {
 public static void main(String[] args) {
 Son son = new Son();
 son.doBusiness(); // 做生意的
 }
}</code></pre><h4 id="%E6%9D%83%E9%99%90%E4%BF%AE%E9%A5%B0%E7%AC%A6" style="background-color:transparent;">权限修饰符</h4><ul>
 <li>可以修饰方法，属性，类。一般都是放在最前面的</li>
 <li>权限修饰符一共有4个，分别是(从大到小)：public，protected，defaule，private</li>
 </ul><table border="1" cellpadding="1" cellspacing="1" style="width:678px;">
 <tbody>
 <tr>
 <td style="width:91px;">权限修饰符</td>
 <td style="width:80px;">同一个类</td>
 <td style="width:78px;">同一个包</td>
 <td style="width:281px;">不同包的子类</td>
 <td style="width:146px;">不同包的非子类</td>
 </tr>
 <tr>
 <td style="width:91px;">private</td>
 <td style="width:80px;">√</td>
 <td style="width:78px;">×</td>
 <td style="width:281px;">×</td>
 <td style="width:146px;">×</td>
 </tr>
 <tr>
 <td style="width:91px;">default</td>
 <td style="width:80px;">√</td>
 <td style="width:78px;">√</td>
 <td style="width:281px;">×</td>
 <td style="width:146px;">×</td>
 </tr>
 <tr>
 <td style="width:91px;">protected</td>
 <td style="width:80px;">√</td>
 <td style="width:78px;">√</td>
 <td style="width:281px;">√（只有继承的，在不同包下才可以访问）</td>
 <td style="width:146px;">×</td>
 </tr>
 <tr>
 <td style="width:91px;">public</td>
 <td style="width:80px;">√</td>
 <td style="width:78px;">√</td>
 <td style="width:281px;">√</td>
 <td style="width:146px;">√</td>
 </tr>
 </tbody>
 </table>private<ul>
 <li>被private修饰的，都是私有成员。只能在本类中才能进行访问</li>
 </ul><pre><code class="language-java">package Person;

public class Father {
 // 私有成员属性
 private int num = 100;
 // 私有的，只能在本类中进行使用
 public void readPrivate() {
 System.out.println("私有变量只能在本类中进行访问：" + num);
 }
}</code></pre>default<ul>
 <li>不写权限修饰符，默认就是这个。只能在本类和同一个包下的类进行使用</li>
 </ul>类A（Person包下）<pre><code class="language-java">package Person;

public class Father {
 // 私有成员属性
 int num = 100;
 // 私有的，只能在本类中进行使用
 public void readPrivate() {
 System.out.println("默认变量可以在本类中进行访问：" + num);
 }
}
</code></pre>类B（Person包下）<pre><code class="language-java">package Person;

public class Son {
 public static void main(String[] args) {
 Father father = new Father();
 father.readPrivate();
 father.num = 10;
 System.out.println(father.num);
 }
}
</code></pre>protected<ul>
 <li>受保护的，只能在本类中，同一个包下，如果不同包，但是有继承关系，这几种情况使用</li>
 </ul>类A（Person包下）<pre><code class="language-java">package Person;

public class Father {
 // 受保护的成员属性
 protected int num = 100;
 // 可以在本类中进行使用
 public void readPrivate() {
 System.out.println("受保护成员变量可以在本类中进行访问：" + num);
 }
}
</code></pre>类B（Person包下）<pre><code class="language-java">package Person;

public class Son {
 public static void main(String[] args) {
 Father father = new Father();
 father.readPrivate();
 // 同一个包下，受保护的成员也可以使用
 father.num = 10;
 System.out.println(father.num);
 }
}
</code></pre>类C（Demo包下）<pre><code class="language-java">package Demo;

import Person.Father;

public class Demo extends Father {
 public void print() {
 System.out.println("父类的受保护成员变量为" + super.num);
 }
}
</code></pre>测试类（Demo包下）<pre><code class="language-java">package Demo;

import Person.Father;

public class PersonTest {
 public static void main(String[] args) {
 // 1. 不同包下
 Father father = new Father();
 // 如果没有继承关系，是访问不了受保护的成员的
 // father.num 编译会直接报错
 // 2. 不同包下，但是有继承关系
 Demo demo = new Demo();
 demo.print();
 }
}
</code></pre>public<ul>
 <li>都可以直接进行使用，权限放开</li>
 </ul>注意事项<ul>
 <li><pre>父类protected修饰的方法，子类对象是不能直接调用的，需要子类进行重写后(并且修饰符要改为public)，子类才能调用</pre></li>
 <li><pre>父类默认权限符修饰的方法，子类对象也是不能直接调用的，需要子类进行重写后(并且修饰符要改为public)，子类才能调用</pre></li>
 </ul>父类（Demo包下）<pre><code class="language-java">package Demo;

public class Father {
 public void a() {
 System.out.println("public");
 }
 protected void a1() {
 System.out.println("protected");
 }
 void a2() {
 System.out.println("default");
 }
}
</code></pre>子类（Demo包下）<pre><code class="language-java">package Demo;

public class Son extends Father {
    @Override
    public void a1() {
        super.a1();
    }

@Override
 public void a2() {
 super.a2();
 }
}
</code></pre>测试类（Demo包下）<pre><code class="language-java">import Demo.Son;

public class Main {
 public static void main(String[] args) {
 Son s = new Son();
 // 可以直接调用public
 s.a(); // public
 // 父类protected修饰的方法，子类对象是不能直接调用的，需要子类进行重写后(并且修饰符要改为public)，子类才能调用
 s.a1(); // protected
 // 父类默认权限符修饰的方法，子类对象也是不能直接调用的，需要子类进行重写后(并且修饰符要改为public)，子类才能调用
 s.a2(); // default
 }
}</code></pre><h4 id="%E5%8C%85package">包package</h4><ul>
 <li>包其实就是文件夹，作用就是对类进行分类管理</li>
 </ul><blockquote>package 包名；</blockquote><ul>
 <li>多级包，则用 . 进行分开</li>
 </ul><blockquote>package 一级.二级....</blockquote>举例：<pre><code class="language-java">package com.Xxx.xx</code></pre><ul>
 <li>就是创建了一个com的文件下，里面有Xxx文件夹，Xxx文件夹下有一个xx的文件夹</li>
 </ul>类的名称<ul>
 <li>类完整名称 = 包的名称 + 类的名称&nbsp; &nbsp; &nbsp;保障类名唯一，不允许重复</li>
 </ul>举例：<pre><code class="language-java">com.minsheng.day01</code></pre><ul>
 <li>在此包下创建一个Demo的类，则此类的完整名称就是 com.minsheng.day01.Demo</li>
 </ul>导包<blockquote>import com.minsheng.day01.*&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// 导入所有import com.minsheng.day01.xxx&nbsp; &nbsp; &nbsp;// 导入具体的单一的类</blockquote><ul>
 <li>如果在同一个包下，默认情况下，不需要写import</li>
 </ul><h4 id="%E7%8A%B6%E6%80%81%E4%BF%AE%E9%A5%B0%E7%AC%A6">状态修饰符final</h4><ul>
 <li>final（最终态），可修饰类，成员变量，成员方法</li>
 <li>被final关键字修饰的类，无法被继承</li>
 <li>被final关键字修饰的成员方法，可以被继承，但是无法被重写</li>
 <li>被final关键字修饰的成员变量，是无法被修改的，并且必须赋初始值。常量名称一般都大写</li>
 </ul>父类<pre><code class="language-java">// 被final修饰的类，是无法被继承的
public class Demo {
 // 被final修饰的成员变量，是不能改变的，并且必须赋初始值。也是不能被继承的
 private final int SUCCESSCODE = 200;
 // 被final修饰的成员方法，可以被继承，但是无法被重写
 public final void print() {
 System.out.println("被final修饰的成员方法，是无法被重写的");
 }
}
</code></pre>子类<pre><code class="language-java">public class Test extends Demo {
 public void fn() {
 super.print();
 }
}
</code></pre>测试类<pre><code class="language-java">public class Main {
 public static void main(String[] args) {
 new Test().fn();
 }
}</code></pre>final还可以修饰局部变量<ul>
 <li>修饰基本数据类型：不能被修改，必须赋初始值</li>
 </ul><pre><code class="language-java">public class Demo {
 public void print() {
 // final修饰局部变量，这个局部变量就不可以被修改了，并且必须赋初始值
 final int age = 24;
 // age = 20; // Cannot assign a value to final variable 'age'
 }
}</code></pre><ul>
 <li>修饰复杂(又叫引用)数据类型：栈内存地址不能够发生改变，但是引用数据类型的内存地址里面的成员属性值是可以变化的</li>
 </ul>类A<pre><code class="language-java">public class Demo {
 int age = 24;
}
</code></pre>测试类<pre><code class="language-java">public class Main {
 public static void main(String[] args) {
 // 被final修饰的复杂数据类型，内存地址不可以变，但是里面的成员变量可以改变
 final Demo demo = new Demo();
 // 改变成员变量
 demo.age = 18;
 System.out.println(demo.age);
 }
}</code></pre></div>原文链接：https://blog.csdn.net/qq_52845451/article/details/130462731

Java学习笔记-03

类与对象

类class

对象

修饰符private

this关键字

构造函数

继承

权限修饰符

包package

状态修饰符final

[原创]mangabz漫画网爬取

算法思想总结：模拟算法

Vue3的侦听器

Vue3的toRaw()与markRaw()

Vue3的Teleport组件

ES6汇总

Linux：Linux发展史

算法思想总结：双指针算法

BFS：边权相同的最短路问题

elementui的form组件中使用日期选择器，整体表单校验失败的解决办法

Java学习笔记-03