面向对象（基础）

原创 已于 2025-06-23 21:35:55 修改 · 999 阅读 · 21 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#java
于 2024-11-20 20:55:42 首次发布

文章目录

面相对象（基础）

一、类与对象

1、类与对象引出

  • 一个养猫的问题

现有技术解决：

  1. 单独的定义变量解决
  2. 单独用数组解决
public class object01 {

    public static void main(String[] args) {
        /*
         * 张老太养了两只猫猫:一只名字叫小白,今年3岁,白色。还有一只叫小花,今年100岁,花色。
         * 请编写一个程序，当用户输入小猫的名字时就显示该猫的名字，年龄，颜色。
         * 如果用户输入的小猫名错误，则显示 张老太没有这只猫猫。
         * */
        // 单独变量来解决 => 不利于数据管理(当猫的数量过多时，当需要新增猫的属性时)
        // 第一只猫信息
        String cat1Name = "小白";
        int cat1Age = 3;
        String cat1Color = "白色";
        //第2只猫信息
        String cat2Name = "小花";
        int cat2Age = 100;
        String cat2color = "花色";

        //数组 ===>(1)数据类型体现不出来（年龄原本是int类型，现在只能用String类型）
        // (2)只能通过[下标]获取信息，造成变量名字和内容的对应关系不明确
        // (3)不能体现猫的行为
        String[] cat1 = {"小白", "3", "白色"};
        String[] cat2 = {"小花", "100", "花色"};
    }
}

java设计者引入类与对象（OOP），根本原因就是现有的技术，不能完美的解决新的需求。

2、类与对象概述

一个程序就是一个世界，有很多的事物，这个事物就是对象。

对象包含两个关键的东西，属性和行为。

比如说，一只小狗就是一个对象，小狗的年龄就是小狗的属性，吃饭就是小狗的行为。

那么类和对象是什么关系呢？

类就是自定义数据类型，对象就是一个类的具体实例

例如：狗类是一个“类”，具体的某一只小狗就是“对象”

java最大的特点就是面向对象！！！

3、面向对象快速入门

面向对象的方式解决养猫问题

/*
* 体验：面相对象解决养猫问题
* */


public class object01 {

    public static void main(String[] args) {
        /*
         * 张老太养了两只猫猫:一只名字叫小白,今年3岁,白色。还有一只叫小花,今年100岁,花色。
         * 请编写一个程序，当用户输入小猫的名字时就显示该猫的名字，年龄，颜色。
         * 如果用户输入的小猫名错误，则显示 张老太没有这只猫猫。
         * */
        // 单独变量来解决 => 不利于数据管理(当猫的数量过多时，当需要新增猫的属性时)
        // 第一只猫信息
        String cat1Name = "小白";
        int cat1Age = 3;
        String cat1Color = "白色";
        //第2只猫信息
        String cat2Name = "小花";
        int cat2Age = 100;
        String cat2color = "花色";

        //数组 ===>(1)数据类型体现不出来（年龄原本是int类型，现在只能用String类型）
        // (2)只能通过[下标]获取信息，造成变量名字和内容的对应关系不明确
        // (3)不能体现猫的行为
        String[] cat1 = {"小白", "3", "白色"};
        String[] cat2 = {"小花", "100", "花色"};

        // 使用OOP面向对象解决
        // 实例化一只猫[创建一只猫对象]
        // new Cat() 创建一只猫
        // Cat oopCat1 = new Cat(); 把创建的猫赋给 oopCat1
        Cat oopCat1 = new Cat();
        oopCat1.name = "小白";
        oopCat1.age = 1;
        oopCat1.color = "白色";
        // 创建第二只猫，并赋值给oopCat2
        Cat oopCat2 = new Cat();
        oopCat2.name = "小黑";
        oopCat2.age = 9;
        oopCat2.color = "黑色";

        // 怎么使用
        System.out.println("第一只猫的名字" + oopCat1.name );
    }
}

// 使用面向对象的方式来解决养猫问题
// 定义一个猫类 => 自定义的数据类型
class Cat{
    // 属性
    String name; // 名字
    int age; // 年龄
    String color; // 颜色

    // 行为
}

通过上面的案例，我们可以看出：

  1. 类是抽象的，概念的，代表一类的事物，例如：人类，猫类……。即它就是数据类型。
  2. 对象是具体的，实际的，代表一个具体事物，即是实例。
  3. 类是对象的模板，对象是类的一个个体，对应一个实例。

4、对象内存布局（重要）

对象在内存中的存在形式是什么样的？（重要）
在这里插入图片描述

类首先会把类信息加载到方法区（主要是属性和行为），然后开始分配空间。分配空间首先在堆中根据不同的属性分配空间。最后再把地址返回给栈中的cat

5、属性的概念

  1. 从概念或叫法上看：成员变量 = 属性 = field
  2. 属性是类的一个组成部分，一般是基本数据类型，也可以是引用数据类型（对象，数组）

注意事项和细节说明

  1. 属性的定义语法同变量，示例： 访问修饰符 属性类型 属性名

  2. 属性的定义类型可以为任意类型，包含基本类型或引用类型。

  3. 属性如果不赋值，有默认值，规则和数组一样，

    int 	0
short 	0
byte 	0
long 	0
float 	0.0
double 	0.0
char 	\u0000
boolean	false
String	null

6、创建对象访问属性

  • 如何创建对象

    1. 先声明再创建

      Cat cat; // 在栈中cat指向一个为空值的空间
cat = new Cat(); // new 之后在堆中开辟空间，同时产生一个地址，并将地址填回 cat 指向的空间

    2. 直接创建

      Cat cat = new Cat();

7、对象分配机制（重要）

// 我们看看下面一段代码
Person p1 = new Person();
p1.age = 10;
p1.name = "小明";
Person p2 = p1;
System.out.println(p2.age)

// 请问：p2.age究竟是多少？并画出内存图

第一段代码：首先在方法区中加载Person类信息，然后在堆中开辟空间，进行默认初始化，并将地址填写到栈中p1指向的空间地址

第二段代码：将10赋值给p1指向的堆中分配的空间中的age

第三段代码：在方法区的常量池中创建一条“小明”数据，并产生地址，然后将地址填写到堆中的name

第四段代码：将p1指向的地址复制了一份给到p2,即p1,p2指向同一个对象（类似于一个人（堆中分配的空间），有人叫他名字p1，有人叫他名字p2，但实际上不管叫p1还是p2，都是在叫那同一个人）

在这里插入图片描述

8、对象创建过程

Java内存的结构分析

  1. 栈：一般存放基本数据类型（局部变量）
  2. 堆：存放对象、数组等
  3. 方法区：常量池（常量，比如字符串），类加载信息

java创建对象的流程简单分析

Person p1 = new Person();
p1.age = 10;
p1.name = "小明";
  1. 先加载Person类信息（属性和方法信息，只会加载一次）
  2. 在堆中分配空间，进行默认初始化，然后把地址赋给 p1，p1就指向对象
  3. 进行指定初始化（即给对象属性赋值）

二、成员方法（重要）

1、成员方法快速入门

基本介绍

​ 在某些情况下，我们需要定义成员方法（简称方法）。比如人类：除了有一些属性外（年龄、姓名……），我们人类还有一些行为比如：说话、吃饭……。这时就要用成员方法来完成。

public class method01 {
    public static void main(String[] args) {
        // 创建对象
        Person p1 = new Person();
        // 调用方法
        p1.speak();
        Integer sum = p1.cal01();
        System.out.println("sum="+ sum);
        Integer sum02 = p1.cal02(10000);
        System.out.println("sum02="+ sum02);
    }
}

class Person{
    String name;
    int age;

    // 方法（成员方法）
    // 添加 speak 成员方法，输出 “我是一个好人”
    // public 表示方法是公开
    // void 表示方法没有返回值
    // speak 方法名   ()是形参列表   {}方法体，可以写我们需要的代码
    public void speak(){
        System.out.println("我是一个好人");
    }

    // 添加 cal01 成员方法，可以计算从 1+..+1000的结果
    public Integer cal01(){
        int sum = 0;
        for (int i = 0; i <= 1000; i++) {
            sum += i;
        }
        return sum;
    }

    // 添加 cal02 方法，可以接收一个数 n ，计算从1+..+n的计算结果
    public Integer cal02(Integer n){
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum += i;
        }
        return sum;
    }
}

2、方法调用机制

  1. 当程序执行到方法时，就会开辟一个独立的空间（栈空间）
  2. 当方法执行完毕后，或者执行到return语句时，就会返回到调用方法的地方
  3. 然后销毁该独立空间
  4. main方法（栈）继续执行后面的代码，main方法执行完毕后，整个程序退出

3、成员方法带来了哪些便利？

看一个需求：

请遍历一个数组，输出数组的各个元素值；

解决思路1：传统的方法，就是使用for循环，将数组输出

public class method02 {

    public static void main(String[] args) {
        // 遍历一个数组，输出数组的各个元素值
        int [][] map = {{0,0,1},{1,1,1},{1,1,3}};
        
        // 遍历 map数组
        // 传统的解决方式就是for循环
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.println(map[i][j]);
            }
            System.out.println();
        }
        
        // ....
        //
        // 要求再次遍历map数组时
        // 如何处理？
    }
}

解决思路2：定义一个MyTools类，然后写一个成员方法。

public class method02 {

    public static void main(String[] args) {
        // 遍历一个数组，输出数组的各个元素值
        int [][] map = {{0,0,1},{1,1,1},{1,1,3}};

        // 遍历 map数组
        // 传统的解决方式就是for循环
        MyTools myTools = new MyTools();
        myTools.printArr(map);
    }
}

class MyTools{

    public void printArr(int [][] map){
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j]);
            }
            System.out.println();
        }
    }
}

使用方法带来的好处：

  1. 提高代码的复用性
  2. 可以将实现的细节封装起来，然后供其他用户来调用即可

4、方法调用的细节说明

  1. 同一个类中方法调用：直接调用即可。
  2. 跨类中方法A类调用B类：需要通过对象名调用。比如：对象名.方法名(参数);
  3. 特别说明：跨类的方法调用和方法的访问修饰符相关。

5、成员方法传参机制（重要）

  1. 基本数据类型的传参机制

    结论：基本数据类型传递的是值（值拷贝），形参的任何改变不影响实参

  2. 应用数据类型的传参机制

    结论：引用数据类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参

三、方法递归

1、什么是方法递归？

  • 方法直接调用自己或者间接调用自己的形式称为方法递归（recursion）
  • 递归作为一种算法在程序设计语言中广泛应用。

2、递归的形式

  • 直接递归：方法自己调用自己
  • 间接递归：方法调用其他方法，其它方法又回调方法自己。

3、方法递归存在的问题？

  • 递归如果没有控制好终止，会出现递归死循环，导致栈内存溢出现象。

4、递归解决问题的思路

  • 把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。

5、递归算法三要素大体可以总结为：

  • 递归的公式
  • 递归的终结点
  • 递归的方向必须走向终结点

6、递归的简单例子

public class recursion01 {
        // 计算1-n的和
        public static void main(String[] args) {
            System.out.println(sum(5));
        }
        private static int sum(int n){
            if (n == 1){
                return 1;
            }else{
                return n + sum(n-1);
            }
        }
}

四、方法重载

在java中，方法重载（Overloading）是一种让类以统一的方式处理不同类型数据或不同数量参数的技术。重载是通过改变方法的参数列表来实现的，包括参数的类型、数量或顺序，而方法的名称和返回类型则保持不变。这使得同一个类中可以存在多个同名方法，只要他们的参数列表不同即可。

1、方法重载的基本规则

  • 方法名必须相同：重载的方法必须具有相同的名称。
  • 参数列表必须不同：这可以通过改变参数的数量、类型或顺序来实现。
  • 返回类型可以不同
  • 修饰符可以不同
  • 异常列表可以不同

2、方法重载示例

public class overloading01 {
    public static void main(String[] args) {
        Count count = new Count();
        System.out.println(count.add(1,1));
        System.out.println(count.add(1.1,1.1));
        System.out.println(count.add(1,1,1));
    }
}
class Count{
    // 第一个加法方法，接受两个int类型的参数
    public int add(int num1, int num2) {
        return num1 + num2;
    }

    // 第二个加法方法，接受两个double类型的参数
    public double add(double num1, double num2) {
        return num1 + num2;
    }

    // 第三个加法方法，接受三个int类型的参数
    public int add(int num1, int num2, int num3) {
        return num1 + num2 + num3;
    }
}

3、方法重载的优点与注意事项

优点：
  • 提高代码可读性：使用不同参数列表的方法，让程序员可以更清楚的表达意图。
  • 提高代码灵活性：方法重载使得类可以更灵活的处理不同类型的数据
  • 减少代码量：不需要为每种数据类型一个单独的函数或类
  • 提高代码的可维护性：更改参数类型或添加新类型的参数通常比修改返回类型或修改方法名称更容易理解和维护。
注意事项：
  • 方法重载不应该改变方法可见性（public,private,protected）。如果改变了方法的可见性，那它就不是真正的重载了。
  • 如果两个方法有相同的参数类型、数量和顺序，但返回类型不同，那么他们不是重载的；他们会引发编译错误，因为java不支持返回类型的重载（C++支持）

五、可变参数

1、可变参数概述

java中，我们可以将名称相同、功能也相同，但是形参个数不同的多个函数，封装为某个类中的一个函数。比如：要求多个数的和，这时我们并不能确定有多少个数，如果每增加一个参数就对应增加一个函数，那就太影响效率了。我们可以通过可变参数的方式来解决这个问题。

2、格式

访问修饰符 返回值类型	函数名 （数据类型...	变量名）	{
	// 方法体
}

// 注意：这里的“数据类型...”是固定格式

3、注意事项

  • 调用可变参数的方法时，传入实参的个数可以是0~n。(n=0,1,2,3)
  • 传入的实参也可以直接是一个数组。
  • 可变参数的本质，其实就是一个数组，因此你也可以把它当做数组来使用。
  • 当形参中既含有可变参数，也含有普通的参数，必须确保可变参数在形参列表的最后。
  • 每个形参列表都只能有一个可变参数。

4、示例

public class variableParameters {
    public static void main(String[] args) {
        Test1 test1 = new Test1();


		// 调用可变参数的方法时，传入实参的个数可以是0~n。（n = 0，1，2......）
        int[] array1 = {2, 11, 211, 985, 141};
        int[] array2 = {1, 2, 7};

        System.out.println(test1.getSum(0,1,2,3,4,5));
        System.out.println(test1.getSum(5,5,5));

        // 传入的实参也可以直接是一个数组
        System.out.println(test1.getSum(array1));
        System.out.println(test1.getSum(array2));
    }
}

class Test1{
    public int getSum(int... paramters){
        System.out.println("可变参数中含有"+paramters.length+"个参数");
        int sum = 0;
        for (int i = 0; i < paramters.length; i++) {
            sum += paramters[i];
        }
        System.out.println("传入总和是："+sum);
        return sum;
    }
}

六、作用域

参考网站：作用域 - Java教程 - 廖雪峰的官方网站

在Java中，我们经常看到的 public、protected、private这些修饰符。在Java中，这些修饰符都可以用来限定作用域。

1、public

  • 定义为 public的 class、interface 可以被其他任何类访问
  • 定义为 public的 field 、 method 可以被其他类访问，前提是有访问 class 的权限
package abc;

public class Hello {
    public void hi() {
    }
}

上面的Hello是public，因此，可以被其他包的类访问

package abc;

public class Hello {
    public void hi() {
    }
}

上面的hi()方法是public，可以被其他类调用，前提是首先要能访问Hello类：

2、private

  • 定义为 private 的 field 、method 无法被其他类访问

说明：

  1. 实际上，确切地说，private访问权限被限定在class的内部，而且与方法声明顺序无关。推荐把private方法放到后面，因为public方法定义了类对外提供的功能，阅读代码的时候，应该先关注public方法：
package abc;

public class Hello {
    public void hello() {
        this.hi();
    }

    private void hi() {
    }
}
  1. 由于Java支持嵌套类，如果一个类内部还定义了嵌套类，那么，嵌套类拥有访问private的权限：
// private
public class Main {
    public static void main(String[] args) {
        Inner i = new Inner();
        i.hi();
    }

    // private方法:
    private static void hello() {
        System.out.println("private hello!");
    }

    // 静态内部类:
    static class Inner {
        public void hi() {
            Main.hello();
        }
    }
}

3、protected

  • protected作用于继承关系，定义为 protected 的字段和方法可以被子类访问，以及子类的子类
package abc;

public class Hello {
    // protected方法:
    protected void hi() {
    }
}

上面的protected方法可以被继承的类访问：

package xyz;

class Main extends Hello {
    void foo() {
        // 可以访问protected方法:
        hi();
    }
}

4、package

最后，包作用域是指一个类允许访问同一个package的没有public、private修饰的class，以及没有public、protected、private修饰的字段和方法。

package abc;
// package权限的类:
class Hello {
    // package权限的方法:
    void hi() {
    }
}

只要在同一个包，就可以访问package权限的class、field和method：

package abc;

class Main {
    void foo() {
        // 可以访问package权限的类:
        Hello h = new Hello();
        // 可以调用package权限的方法:
        h.hi();
    }
}

注意，包名必须完全一致，包没有父子关系，com.apache和com.apache.abc是不同的包。

5、局部变量

在方法内部定义的变量称为局部变量，局部变量作用域从变量声明处开始到对应的块结束。方法参数也是局部变量。

package abc;

public class Hello {
    void hi(String name) { // 1
        String s = name.toLowerCase(); // 2
        int len = s.length(); // 3
        if (len < 10) { // 4
            int p = 10 - len; // 5
            for (int i=0; i<10; i++) { // 6
                System.out.println(); // 7
            } // 8
        } // 9
    } // 10
}

我们观察上面的hi()方法代码：

  • 方法参数name是局部变量，它的作用域是整个方法，即1 ~ 10；
  • 变量s的作用域是定义处到方法结束，即2 ~ 10；
  • 变量len的作用域是定义处到方法结束，即3 ~ 10；
  • 变量p的作用域是定义处到if块结束，即5 ~ 9；
  • 变量i的作用域是for循环，即6 ~ 8。

使用局部变量时，应该尽可能把局部变量的作用域缩小，尽可能延后声明局部变量。

6、final

Java还提供了一个final修饰符。final与访问权限不冲突，它有很多作用。

  • 用final修饰class可以阻止被继承：
package abc;

// 无法被继承:
public final class Hello {
    private int n = 0;
    protected void hi(int t) {
        long i = t;
    }
}
  • 用final修饰method可以阻止被子类覆写：
package abc;

public class Hello {
    // 无法被覆写:
    protected final void hi() {
    }
}
  • 用final修饰field可以阻止被重新赋值：
package abc;

public class Hello {
    private final int n = 0;
    protected void hi() {
        this.n = 1; // error!
    }
}
  • 用final修饰局部变量可以阻止被重新赋值：
package abc;

public class Hello {
    protected void hi(final int t) {
        t = 1; // error!
    }
}

7、最佳实践

  • 如果不确定是否需要public，就不声明为public，即尽可能少地暴露对外的字段和方法。

  • 把方法定义为package权限有助于测试，因为测试类和被测试类只要位于同一个package，测试代码就可以访问被测试类的package权限方法。

  • 一个.java文件只能包含一个public类，但可以包含多个非public类。如果有public类，文件名必须和public类的名字相同。

8、小结

  • Java内建的访问权限包括public、protected、private和package权限；
  • Java在方法内部定义的变量是局部变量，局部变量的作用域从变量声明开始，到一个块结束；
  • final修饰符不是访问权限，它可以修饰class、field和method；
  • 一个.java文件只能包含一个public类，但可以包含多个非public类。

七、递归函数

作者在实际开发经验中很少用到递归，因此此处不做详细说明

1、递归原理

递归是基于函数调用栈的原理实现的。当一个方法被调用时，会在调用栈中创建一个对应的栈帧，包含方法的参数、局部变量和返回地址等信息。在递归中，方法会在自身的定义中调用自身，这会导致多个相同方法的栈帧依次入栈。当满足条件时，递归开始回溯，栈帧依次出栈，方法得以执行完毕。

2、递归的实现方法

  • 终止条件：定义递归结束的条件（无适当的终止条件可能会使递归陷入无限循环，，导致栈溢出）
  • 递归调用：在方法定义中调用自身。

八、构造器

1、什么是构造器

构造器通常也叫构造方法、构造函数，它在类的实例化过程中被调用，用来初始化新对象（给对象赋初始值），即我们在new一个对象时，JVM就会自动调用构造器，那么为什么在之前我们没有创建构造器时，也可以new一个对象呢？因为java系统会提供一个默认的构造器。

2、构造器的基本语法

构造方法的名字必须和所在类名字一致，没有返回值，但不能声明 void ，访问权限可以为任意，但一般情况下使用public方法权限，构造方法中的参数可以自定义，参数不同的构造方法构成重载。

public class ClassName {
    // 构造器
    public ClassName() {
        // 初始化代码
    }
}
  1. 构造器的名称必须和类名一致
  2. 一个类中可以定义多个构造器，但是构造器的参数列表必须不同（重载）
  3. java系统会在没有手动定义构造器时提供一个默认的构造器（默认构造器不做任何操作，只单纯创建一个对象），手动定义后，默认的构造器会被收回
  4. 代码游离块先执行

3、 构造器的类型

3.1、默认构造器

由java编译器自动提供的一个无参默认构造器，在手动创建构造器后，该默认构造器会被回收

public class Constructortest01 {

    public static void main(String[] args) {
        test01 test01 = new test01();//使用默认构造器
    }
}

class test01 {
// 编译器自动提供一个默认无参的构造器
}
3.2、无参构造器

无参构造器是用户自己定义的一个不传递参数的构造器

public class Constructortest02 {
    public static void main(String[] args) {
        test02 test02 = new test02();// 调用自定义无参构造器，此时编译器提供的默认构造器被回收
        System.out.println(test02.name + ":"+test02.sex);
    }
}


class test02{
    String name;
    String sex;

    // 定义无参构造器
    public test02(){
        name = "小明";
        sex = "男";
        System.out.println(name + ":"+ sex );
    }
}
3.3、有参构造器

有参构造器是用户自己定义的一个传递参数的构造器（可以重载）

public class Constructortest03 {

    public static void main(String[] args) {
        //调用无参构造器
        test03 test03 = new test03();

        // 调用有参构造器
        test03 小明 = new test03("小明");
        test03 test031 = new test03("小明", "男");
        test03 test032 = new test03("小明", "男", 12);
    }
}


class test03{
    String name;
    String sex;
    int age;

    // 无参
    public test03(){
        System.out.println("无参构造器");
    }

    // 有参以及重载
    public test03(String name){
        this.name = name;
        System.out.println(this.name +":"+this.sex +":"+this.age);
    }
    public test03(String n,String s ){
        name = n;
        sex = s;
        System.out.println(name +":"+sex +":"+age);
    }
    public test03(String n , String s , int a){
        name = n;
        sex = s;
        age = a;
        System.out.println(name +":"+sex +":"+age);
    }

}

4、构造器的使用

  1. 使用new时（类初始化时的()中填入不同参数以及类型，调用对应的构造器）
  2. 使用this（同一类中一个构造器调用另一个构造器，必须在第一行使用this）
  3. 使用super（子类构造器调用父类构造器）
4.1、使用this调用构造器

当我们需要在同一类中的一个构造器中调用另一个构造器时，就需要使用this关键字。

当使用this关键字调用同一类中的另一个构造器时，this必须是构造器中的第一条语句。

public class Constructortest04 {
    public static void main(String[] args) {
        Test04 test04 = new Test04("小明", "男", 12);
    }
}

class Test04 {
    String name;
    String sex;
    int age;

    public Test04(String n){
        name = n;
        System.out.println("调用一个参数");
        System.out.println(name +":"+sex +":"+age);
    }

    public Test04(String n , String s , int a){
        this(n);
        System.out.println(name +":"+sex +":"+age);
    }
}
4.2、构造器的继承

首先，构造器是不能继承的，但是子类可以调用父类的构造器。子类构造器会默认调用父类的无参构造器，如果父类没有无参构造器，则必须在子类构造器的第一行通过super关键字来指定调用父类中的哪个构造器。

4.3、使用super调用父类构造器

当我们想要调用父类构造器时，就需要使用super关键字。

super关键字可以调用父类关键字，在使用时必须放在子类构造器中的第一行。

public class Constructortest05 {

}

class Test05 extends Test04{

    // 子类构造器Test05，调用父类有参构造器 Test04(String n)
    public Test05(String n) {
        super(n);
    }
}

、使用this调用构造器

当我们需要在同一类中的一个构造器中调用另一个构造器时，就需要使用this关键字。

当使用this关键字调用同一类中的另一个构造器时，this必须是构造器中的第一条语句。

public class Constructortest04 {
    public static void main(String[] args) {
        Test04 test04 = new Test04("小明", "男", 12);
    }
}

class Test04 {
    String name;
    String sex;
    int age;

    public Test04(String n){
        name = n;
        System.out.println("调用一个参数");
        System.out.println(name +":"+sex +":"+age);
    }

    public Test04(String n , String s , int a){
        this(n);
        System.out.println(name +":"+sex +":"+age);
    }
}
4.2、构造器的继承

首先，构造器是不能继承的，但是子类可以调用父类的构造器。子类构造器会默认调用父类的无参构造器，如果父类没有无参构造器，则必须在子类构造器的第一行通过super关键字来指定调用父类中的哪个构造器。

4.3、使用super调用父类构造器

当我们想要调用父类构造器时，就需要使用super关键字。

super关键字可以调用父类关键字，在使用时必须放在子类构造器中的第一行。

public class Constructortest05 {

}

class Test05 extends Test04{

    // 子类构造器Test05，调用父类有参构造器 Test04(String n)
    public Test05(String n) {
        super(n);
    }
}
量子纠错码原理与恢复操作正交性解析
最新发布
weixin_30825199的博客
04-21 828
量子纠错码（QEC）是量子计算中保护量子信息免受噪声干扰的关键技术，其核心在于通过多物理比特编码分散逻辑信息。在纠错过程中，恢复操作的正交性条件PU†kUℓP=0确保不同错误类型的可区分性，这是实现高效纠错的数学基础。以表面码为例，该条件对应着错误症状测量的唯一性，使得Pauli门操作能精准复位量子态。针对振幅阻尼等特定噪声模型设计的四量子比特码，通过优化恢复操作显著提升纠错阈值。随着量子硬件发展，如何平衡纠错资源开销与保真度成为工程实践重点，这推动着噪声自适应编码和分布式测量架构等创新方向。
面向对象的概念
千锋教育
05-12 1669
●我们以后的编程思想是，每一个功能，都先创造一个 面馆，这个 面馆 能帮我们作出一个 面（完成这个功能的对象），然后用 面馆 创造出一个 面，我们只要等到结果就好了。■动态语言是在运行时确定数据类型的语言。■JavaScript能够动态修改对象的属性，没有办法在编译的时候知道变量的类型，只有在运行的时候才能确定。●重点： 在函数的 prototype 里面存储的内容，不是给函数使用的，是给函数的每一个实例化对象使用的。○在面向过程的时候，我们要关注每一个元素，每一个元素之间的关系，顺序，。
面向对象基本概念
热门推荐
Superme
02-06 19万+
面向对象就是：把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。对同类对象抽象出其共性，形成类。类中的大多数数据，只能用本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。程序流程由用户在使用中决定。对象即为人对各种具体物体抽象后的一个概念，人们每天都要接触各种各样的对象，如手机就是一个对象。 面向对象编程（OOP：object-orie...
什么是面向对象？你了解吗？（超细讲解）
m0_64892344的博客
05-04 4540
就是将一件“大事”，按一些更小的步骤（小事）顺序去一个一个完成。这几乎符合人类的基本行为习惯。思想演示举例第一步，学生提出要报名，并提供姓名和照片第二步，咨询老师接收照片并登记学生姓名第三步，学生缴费（付款到学校账号）并获得缴费凭证第四步，咨询老师验证凭证并分配班级第五步，最终结果为：报名完成，学生可以在规定的时间到规定的班级（教室）上课，数据库中就有了该学生的信息。
什么是面向对象？
weixin_61665636的博客
11-25 1万+
象原型__proto__和构造函数原型对象prototype都有一个属性，叫做constructor，称之为构造函数，主要记录该对象引用了哪个构造函数，可以让原型对象重新指向原来的构造函数，这就是为什么在实例对象中传递参数时，构造函数本身不需要写return返回结果的原因。属性是对象的状态，方法是对象的行为（完成某种任务）。即this作用域的问题。是一种特殊的函数，主要用来初始化对象，即为对象成员变量赋初始值，它总是与new一起使用，我们可以把对象中的一些公共的属性和方法抽取出来，然后封装到这个函数里面。
什么是面向过程和面向对象，有什么区别？
胡晗靓的Java学习博客
07-01 2万+
什么是面向过程和面向对象，有什么区别？
Java面向对象基础
LyncDwight的博客
05-29 1万+
面向对象 学习内容 l 面向对象思想 l 类与对象及其使用 l 对象的内存图 l 成员变量和局部变量的区别 l 匿名对象 l 封装(private) l this关键字 l 构造方法 l static关键字 l 继承 l 多态 l 抽象类 l 接口 l 包和导包...
面向对象基础总结
一想天开
04-25 476
从今天起，我打算开始研究一下设计模式，以前也有涉及过这方面的知识，不过都不够深入和系统，最近正好静下心来总结一下，今天先从最简单的面向对象基础开始。 1.类与实例    类就是具有相同的属性和功能的对象的抽象的集合。类名一般要大写。比如说人类，人类都有眼睛，手，脚，这些是人都有的属性。而人能够吃饭，唱歌，跑步，这些是人能完成的功能。我是人类，所以我就是人类的一个具体的实例。 2.构造方法
PHP面向对象基础
末初 · mochu7
04-09 1263
转载自：黑马程序员武汉中心 文章目录面向对象基础一、面向对象编程思想**二、面向对象基础****1、面向对象关键字说明****2、面向对象简单技术实现****3、类成员****4、访问修饰限定符****5、类内部对象****6、面向对象开发规范****7、构造方法****8、析构方法****9、对象传值****10、范围解析操作符（类常量访问）****11、静态成员****12、self关键字**...
Java基础篇面向对象作业—01
Steven_YE
07-15 223
Java基础篇面向对象作业—01 问题一：什么是面向对象？ 面向对象是一种编程思维，是相对于传统的面向过程的思维来讲的； 传统的面向过程强调的是解决问题的具体步骤，具体方法，编程思路是自顶向下，不断分解地解决问题。 面向对象更加强调解决问题的主体，谁来解决问题，创建可以解决问题的对象，来操作数据，面向对象的编程思路是自底向上，不断拼接； 面向对象的好处有很多，比如面向对象更符合人类的思维模...
面向对象（详解）
bu_xiang_tutou的博客
04-02 1957
java类名必须是一个或多个有意义的单词连缀而成，每个单词首字母大写，其他小写。单词与单词之间没有分隔符。构造器，成员变量，方法，初始化块，内部类。构造器，成员变量，方法。
面向对象（OOP）
天宇龙腾的博客
12-02 4681
面向对象程序设计（OOP - object oriented programming） 面向对象程序由对象组成，每个对象对用户公开特定功能并隐藏实现的部分，很多的对象来自Java标准库，也存在一部分是开发者自定义的，只要当前对象能够满足要求，就不必去关心其功能是如何实现的。 面向对象将数据放在第一位，再去考虑操作数据的算法，操作数据的过程也就被称为方法。 类便是构建对象的模板，由类构造对象的过程称为创建类的实例。创建时使用构造器（构造函数）创建新实例（对象），如果希望构造的对象可以多次使用，那么就会将对象存
面向对象详解
qq_46189388的博客
11-29 4204
类，是一个抽象的概念，不能直接使用，要使用类中的属性和功能，必须对类进行实例化，我们可以使用关键字new（静态Static修饰的不需要new来实现）。而实际上我们在创建对象时，除了使用关键字new之外，还得借助构造方法来完成对类的实例化。
面向对象程序设计（基础篇）
tan091299的博客
04-14 1806
类主要由变量和方法组修饰符 变量类型 变量名 = [默认值];修饰值 返回值类型 方法名(形参列表){}例：创建三个空白类public class 类1{class 类2{class 类3{修饰符 类名(形参类型){}
【Java基础篇】面向对象(Object Oriented)
输入技术、输出想法
08-24 3879
面向对象(Object Oriented）1. 面向对象概念1.1 什么事面向对象1.2 理解面向对象1.3 面向对象的特点1.4 面向对象开发设计,特征2. 类与对象2.1 什么是类2.2 类与对象的关系3. 类的定义4. 成员变量与局部变量的区别4.1 成员变量4.2 局部变量4.3 成员变量初始化5. 创建对象,使用对象6. 对象内存结构6.1 对象的产生6.2 对象的生命周期7. 匿名对象 1. 面向对象概念 1.1 什么事面向对象 面向对象(Object Oriented)是一种思想，90年代以
面向对象(OOP)
Kaka_csdn14的博客
12-02 771
Java面向对象 基础部分内容详解 包括面向对象是什么; 类和对象的概念; 构造器; this和static关键字; block和debug; 以及封装入门
面向对象的三个基本特征 和 五种设计原则
firefly_2002的专栏
09-22 1991
一、三个基本特征 面向对象的三个基本特征是：封装、继承、多态。 封装 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 继承 面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需
什么是面向对象
记录学习路上的每一个 “啊哈！” 时刻 欢迎交流，共同进步！
04-22 2754
本文主要帮助大家理解，到底什么是面向对象。提示：以下是本篇文章正文内容，下面案例可供参考。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值