javaSE-面向对象部分复习笔记

目录

1.构造方法

2.类和对象在内存中的表现形式

3.成员变量和局部变量

4. static关键字的作用

5. this关键字

6.构造器

7.方法重载

8.继承、封装、多态

9.内部类

---

1.构造方法

public class a7251 {
    int a;
    int b;
    String c;

    public a7251(int a) {
        this.a = a;
    }
//    传入相同类型参数的构造方法只能存在一个
//    已在 'a7251' 中定义 'a7251(int)'
//    public a7251(int b) {
//        this.b = b;
//    }

    public a7251(String c) {
        this.c = c;
    }
}

new关键字调用构造方法，创建对象，构造方法是对该新生成对象属性值初始化的过程。

2.类和对象在内存中的表现形式

栈：存放基本类型的数据和对象的引用变量的数据，但对象本身不存放在栈中，而是存放在堆中（new 出来的对象）

堆：存放用new产生的对象数据，每个对象包含了一个与之对应的 class 类的信息。

方法区（又称为静态区）：存放对象中用static定义的静态成员

常量池：通常用来存放常量数据、静态变量、类的加载信息等

当多个对象的引用指向同一个内存空间(变量所记录的地址值是一样的) 只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。

3.成员变量和局部变量

区别：

        类中位置不同:成员变量(类中方法外)局部变量(方法内部或方法声明上)

生命周期不同:

        成员变量(随着对象的存在而存在，随着对象的消失而消失)

        局部变量(随着方法的调用而存在，随着方法的调用完毕而消失)

初始化值不同:

        成员变量(有默认初始化值)

        局部变量(没有默认初始化值，必须先定义，赋值才能使用)

4. static关键字的作用

4.1.声明类变量：属于类而不是实例，对于该类的所有实例共享，可直接访问不需创建实例

public class MyClass {
    static int count = 0;
    public void doSomething() {
        count++;
    }
}

4.2.类方法：它属于类而不是类的实例。可以被类的所有实例共享，并且不需要创建类的实例就可以调用

public class MyClass {
    static int count = 0;
    static void printCount() {
        System.out.println("Count: " + count);
    }
}

MyClass.printCount(); 

4.3静态内部类：内部类可以声明为 static，这意味着它不依赖于外部类的实例，可以直接通过类名访问。

public class OuterClass {
    static class InnerStaticClass {
        public void doSomething() {
            System.out.println("Inner static class method");
        }
    }
}

OuterClass.InnerStaticClass inner = new OuterClass.InnerStaticClass();
inner.doSomething();

4.4静态导入：Java 9 引入了静态导入，允许直接从类中导入静态成员，而不需要使用类名。

import static java.lang.Math.PI;

double area = PI * radius * radius;

4.5静态块：静态块是在类加载时执行的代码块，通常用于初始化静态变量。

public class MyClass {
    static {
        System.out.println("Class is loaded");
    }
}

5. this关键字

概述:this修饰的变量用于指代成员变量，其主要作用是(区分局部变量和成员变量的重名问题)。方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

this 关键字是一个特殊的引用，它指向当前对象的实例。

在方法内部，this 引用当前对象；

在构造器内部，this 引用当前正在创建的构造器的对象。

6.构造器

1. 名称与类名相同：构造器的名称必须与类名完全相同

2. 没有返回类型：构造器不能有返回类型

3. 参数列表：构造器可以有参数，这些参数用于初始化对象的属性。

4. 初始化对象属性：构造器为对象分配内存并初始化其属性。

5. 构造器重载：一个类可以有多个构造器，只要它们的参数列表不同即可。

6. 构造器链：在Java中，如果一个类继承了另一个类，就可以使用基类的构造器来创建子类的对象。

7. 默认构造器：即使一个类有参数构造器，编译器仍然会生成一个默认构造器。

7.方法重载

方法重载（Method Overloading）允许在同一个类中定义多个方法，这些方法具有相同的方法名，但参数列表不同。通过方法重载，可以创建一组具有相似功能但具有不同参数的方法，构造方法是常见的方法重载。

1. 方法名相同：方法重载要求所有重载的方法具有相同的方法名。

2. 参数列表不同：每个重载的方法必须具有不同的参数列表，包括参数的数量、类型或顺序。

3. 返回类型可以相同也可以不同：重载的方法可以具有相同的返回类型，也可以有不同的返回类型。

4. 重载与重写（Override）的区别：方法重载是在同一个类中定义的，而方法重写是在子类中重写父类的方法。

5. 方法重载的选择：当调用重载的方法时，Java编译器会根据传递给方法的参数自动选择合适的方法。如果编译器无法确定调用哪个方法，会抛出一个编译时错误。

6. 参数顺序和类型：参数顺序的不同可以作为重载的依据。

7. 只有返回值类型不同不算方法重载，因为方法签名包括方法名和参数

public class Example {
    public int add(int a, int b) {
        return a + b;
    }
    
    public String add(String a, String b) {
        return a + b;
    }
    //public void add(String a, String b) {
    //
    //}

}

8.继承、封装、多态

继承、封装和多态是面向对象编程（OOP）的三个核心概念。

1. 继承（Inheritance）： 它允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以扩展或修改父类的功能，实现代码的重用和扩展。

   • 单一继承：Java不支持多继承，即一个类只能有一个直接父类。

   • 重写（Override）：子类可以重写父类的方法，实现对父类方法的修改或扩展。

   • 重载（Overload）：子类可以重载父类的方法，即使用不同的参数列表定义相同的方法名。

2. 封装（Encapsulation）： 将数据（属性）和操作数据的方法（行为）封装在一起，隐藏内部实现细节，只对外公开接口。封装有助于提高代码的安全性和可维护性。

   • 私有属性：通过将属性声明为private，可以防止外部直接访问和修改。

   • 公共方法：通过提供公共方法（getter和setter）来访问和修改私有属性。

   • 构造器：初始化对象的状态,私有属性在构造器中设置。

   • 接口：接口定义了一组方法签名，子类必须实现这些方法。

3. 多态（Polymorphism）： 多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中去找的。不满足多态的函数调用时编译时确认好的。

   • 接口实现：子类实现接口的方法，使得子类对象能够以不同的方式响应相同的消息。

   • 方法重载：同一个类中的方法可以有不同的参数列表，通过参数的不同，可以实现多态。

   • 绑定方式：

     静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载；动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

Animal d1 = new Dog("xiaoming"); //任何子类都可以代替父类对象

9.内部类

在一个类里面定义另一个类，这样的类称为内部类。广义上内部类一共有四种：成员内部类、局部内部类、静态内部类、匿名内部类。

①内部类可以写在在类体内的任意地方(成员变量和局部变量可以放的地方)

        a.在成员位置static修饰的----->静态成员内部类(唯一可声明静态属性的内部类)

        b.在成员位置没有static修饰的-----> 普通成员内部类

        c.在非成员位置，其他结构体内(例如方法体内)---->局部内部类

        d.特殊内部类----->匿名内部类

②内部类和外部类 什么关系

        a.静态成员内部类可以访问外部类的静态资源， 外部类可以访问静态成员内部类的所有资源，可以访问外部类的非静态资源

        b.普通成员内部类、外部类可以访问普通成员内部类的所有资源

        -->总结:静态/普通成员内部类对象/实例对象的生成依赖外部类

        静态内部类只能访问外部类静态的方法和属性。其余的内部类可以访问所有的外部类成员变量及方法。静态内部类不依赖于外部类存在。

        其他内部类可以访问外部类是因为持有了外部类的引用。内部类对象依赖于外部类对象存在。创建内部类对象之前，必须先创建外部类对象实例。

        反过来，外部类不能直接使用内部类的成员变量和方法。必须先创建内部类的对象再通过内部类对象访问其方法。

        c.局部内部类

        有生命周期可以访问外部类的任意资源，外部类使用不了局部内部类的任何资源：获取不了局部内部类的类对象

        d.匿名内部类

        可以在成员位置，可以在局部变量位置，没有名字，可以使用外部类的所有资源，外部类不能使用其资源。

        匿名内部类的格式：父类/接口 对象 = new 父类/接口（）{ 重写父类/接口中的方法 }；

        这样做就把子类继承父类，重写父类中的方法，创建子类对象，合成了一步完成，减少了其中创建子类的过程。或者将实现类实现接口，重写接口中的方法，创建实现类对象，合成了一步完成，减少了其中创建实现类的过程。

public class Demo {
    private Runnable runnable = new Runnable() {
        @override
        public void run() {}
    }
}

③内部类与外部类的子类没有关系

仅为个人笔记记录，拿来复习嘻嘻