java基础---面向对象基础知识-CSDN博客

一.访问控制

只针对类，对象，属性。

private->default->protected->public(控制级别由小到大)

二.面向对象三大特性

1.封装

好处：可以对类中的成员变量的访问做出一些限定，不允许外界随意访问。但是可以通过该类提供的方法实现对内部信息的操作访问。

如何实现封装？

1.将类中的属性私有化（使用private关键字修饰）

2.若想访问私有属性，通过setter和getter方法设置和获取属性值（系统提供）

public class Person {
    private String name;    //属性私有化
    private int age;

    public String getName() {   //设置setter和getter方法
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 0) {
            this.age = age;
        } else {
            System.out.println("年龄必须大于0");
        }
    }
}

2.继承

特点：表示事务之间的所属关系，使用extends关键字表示。

class ParentClass {
    // 父类的属性和方法
}

class ChildClass extends ParentClass {
    // 子类的属性和方法
}

注意：

1.子类不仅可以继承父类的属性和方法，也可以定义自己的属性和方法。

2.类只支持单继承，不允许多继承

3.多个类可以继承一个父类

4.子类不能直接访问和调用父类的私有成员，但是可以调用父类的非私有方法

3.多态

特点：指同一操作作用于不同对象时产生不同的行为（方法）

Java中多态分为编译时多态（方法重载）和运行时多态（方法重写与对象向上转型）。

编译时多态（静态多态）

通过方法重载（Overloading）实现，即在同一个类中定义多个同名方法，但参数列表不同（类型、数量或顺序）。编译器在编译阶段根据参数类型决定调用哪个方法。

// 示例：方法重载  
class Calculator {  
    int add(int a, int b) { return a + b; }  
    double add(double a, double b) { return a + b; }  
}

运行时多态（动态多态）

通过方法重写（Overriding）和继承实现，子类重写父类的方法后，程序运行时根据对象的实际类型调用对应方法。需满足以下条件：

继承关系：子类继承父类。

方法重写：子类重写父类的方法（方法名、参数列表、返回类型相同）。

向上转型：父类引用指向子类对象（如 Parent obj = new Child()）。

// 示例：方法重写  
class Animal {  
    void sound() { System.out.println("Animal makes sound"); }  
}  
class Dog extends Animal {  
    @Override  
    void sound() { System.out.println("Dog barks"); }  
}  

public class Main {  
    public static void main(String[] args) {  
        Animal obj = new Dog(); // 向上转型  
        obj.sound(); // 输出 "Dog barks"  
    }  
}

注意事项

成员变量无多态：多态仅适用于方法，成员变量访问取决于引用类型。

静态方法无多态：静态方法属于类，调用时看引用类型而非实际对象。

私有方法不可重写：私有方法无法被继承，故不能多态。

// 示例：成员变量无多态  
class Parent { int val = 1; }  
class Child extends Parent { int val = 2; }  

Parent obj = new Child();  
System.out.println(obj.val); // 输出 1（看引用类型）

4.方法的重写

特点：指子类重新定义父类中已存在的方法。重写的方法必须与父类方法具有相同的名称、参数列表和返回类型。通过方法重写，子类可以根据自身需求改变父类方法的实现。

重写规则：

子类方法的名称、参数列表和返回类型必须与父类方法完全一致。
子类方法的访问权限不能低于父类方法的访问权限。
父类方法若为final或static，则不能被重写。

子类方法抛出的异常类型不能比父类方法抛出的异常类型更宽。

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound(); // Output: Dog barks
    }
}

方法重写与重载的区别

方法重写与方法重载（Overloading）是两个不同的概念：

重写发生在父子类之间，要求方法名完全相同
重载发生在同一类中，要求方法名相同且参数列表不同
使用@Override注解可以帮助编译器检查方法重写的正确性。

5.super关键字

super特点：用于在子类中调用父类的成员（属性或方法）。

super与this的区别

super指向父类对象引用，this指向当前对象引用
super用于访问父类成员，this用于访问当前类成员
super()调用父类构造方法，this()调用本类其他构造方法

注意事项：

1.构造方法中super()或this()必须放在第一行

2.普通方法中super可以出现在任意位置

3.若父类没有无参构造且未显式调用super，编译器将报错

6.this关键字

特点：主要用于区分实例变量和局部变量，尤其是在变量名相同时。this 可以帮助明确访问当前对象的成员变量或方法。

1.使用 this 区分类成员与局部变量

当方法的参数名与类的成员变量名相同时，可以使用 this 来区分成员变量和局部变量。

public class Example {
    private int value;

    public void setValue(int value) {
        this.value = value; // 使用 this 指向成员变量
    }
}

2.使用 this 调用当前类的方法

this 可以用于调用当前类的其他方法，通常用于在方法中调用另一个方法。

public class Example {
    public void methodA() {
        System.out.println("Method A");
    }

    public void methodB() {
        this.methodA(); // 使用 this 调用方法
    }
}

3.使用 this 调用当前类的构造函数

this 可用于在一个构造函数中调用另一个构造函数，但必须作为构造函数的第一条语句。

public class Example {
    private int x;
    private int y;

    public Example() {
        this(0, 0); // 调用带参数的构造函数
    }

    public Example(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

4.this 作为参数传递

this 可以作为参数传递给方法或构造函数，常用于将当前对象传递给其他方法。

public class Example {
    public void print() {
        display(this); // 传递当前对象
    }

    public void display(Example obj) {
        System.out.println("Displaying object");
    }
}

5.this 在匿名类和内部类中的使用

在匿名类或内部类中，this 指向的是当前匿名类或内部类的实例。如果需要访问外部类的实例，可以使用 OuterClassName.this。

public class Outer {
    private int value = 10;

    public class Inner {
        private int value = 20;

        public void print() {
            System.out.println(this.value); // 输出 20
            System.out.println(Outer.this.value); // 输出 10
        }
    }
}

this 的注意事项

this 不能在静态方法或静态代码块中使用，因为静态成员属于类而非实例。使用 this 会导致编译错误。

public class Example {
    private static int count;

    public static void printCount() {
        // System.out.println(this.count); // 编译错误
    }
}

7.构造方法

特点：用于创建对象时初始化对象的状态。构造方法的名称必须与类名完全相同，且没有返回类型（包括void）。

1.默认构造方法

如果一个类没有显式定义构造方法，Java编译器会自动提供一个无参数的默认构造方法。默认构造方法会将成员变量初始化为默认值（如int为0，对象为null）。

public class Person {
    private String name;
    // 默认构造方法（隐式存在）
    // public Person() {}
}

2.自定义构造方法

可以定义带参数的构造方法，用于在对象创建时直接初始化成员变量。

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

    // 自定义构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

3.构造方法的重载

一个类可以有多个构造方法，只要它们的参数列表不同（方法重载）。

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

    // 无参构造方法
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    // 带参构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

4.构造方法与`this`关键字

在构造方法中，this关键字可用于调用同一类的其他构造方法（必须放在第一行）。

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

    public Person() {
        this("Unknown", 0); // 调用带参构造方法
    }

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

5.构造方法的访问修饰符

构造方法可以设置为public、protected、private或默认

public class Singleton {
    private static Singleton instance;

    // 私有构造方法
    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

6.构造方法与继承

子类构造方法默认调用父类的无参构造方法（通过super()）。如果父类没有无参构造方法，子类必须显式调用父类的带参构造方法。

public class Animal {
    private String type;

    public Animal(String type) {
        this.type = type;
    }
}

public class Dog extends Animal {
    public Dog() {
        super("Dog"); // 必须调用父类带参构造方法
    }
}

8.final关键字

特点：用于声明不可变的实体。通常用于变量、方法或类，表示一旦定义后不可修改、重写或继承。

1.final在变量中的使用

当用于变量时，final表示该变量只能被赋值一次，后续不可更改。

final int MAX_VALUE = 100;
// MAX_VALUE = 200;  // 编译错误，不可重新赋值

对于基本类型，final使值不可变。

对于对象引用，final使引用不可变（即不能指向其他对象），但对象内部状态可能仍可修改。

2.final在方法中的使用

当用于方法时，final表示该方法不能被子类重写（覆盖）。

class Parent {
    final void display() {
        System.out.println("不可重写的方法");
    }
}
class Child extends Parent {
    // void display() { }  // 编译错误，无法重写final方法
}

3.final在类中的使用

当用于类时，final表示该类不能被继承。

final class ImmutableClass { }
// class SubClass extends ImmutableClass { }  // 编译错误，不可继承final类

9.抽象类

特点：是一种不能被实例化的类，通常用作其他类的基类。它包含抽象方法（没有具体实现的方法）和具体方法（有实现的方法）。抽象类的主要目的是为子类提供通用的接口和部分实现，强制子类完成特定的功能。

抽象类适合用于定义一组相关类的共同行为，同时允许某些行为由子类具体实现。

抽象类定义规则：

1.包含抽象方法的类必须是抽象类

2.抽象类和抽象方法都需要使用abstract关键字声明

3.抽象方法只需要生命不需要实现

4.如果一个类继承了抽象类，那该子类必须实现抽象类中的全部抽象方法

抽象类与接口的区别

抽象类可以包含方法的实现，而接口只能包含抽象方法（Java 8之前）。一个类可以实现多个接口，但只能继承一个抽象类。抽象类更适合用于共享代码或状态，而接口更适合定义行为契约。

抽象类可以有构造方法，接口不能有构造方法。抽象类的成员变量可以是任何访问修饰符，接口的成员变量默认是public static final。抽象类的抽象方法可以是public、protected，接口的方法只能是public。

// 抽象类定义
abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    // 抽象方法
    public abstract void makeSound();

    // 具体方法
    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类实现
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog("Buddy");
        dog.makeSound();
        dog.eat();
    }
}

10.接口

特点：用于定义一组方法而不提供实现，可以实现多继承。接口通过interface关键字定义，类可以通过implements关键字实现接口。

public interface Vehicle {
    void start();
    void stop();
    String getType();
}

1.实现接口

类实现接口时必须提供接口中所有方法的实现，否则必须声明为抽象类。

public class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("Car started");
    }

    @Override
    public void stop() {
        System.out.println("Car stopped");
    }

    @Override
    public String getType() {
        return "Automobile";
    }
}

2.接口的默认方法

Java 8开始允许在接口中定义默认方法，提供方法的默认实现。实现类可以选择重写默认方法或直接使用默认实现。

public interface Vehicle {
    void start();
    void stop();
    
    default String getType() {
        return "Generic Vehicle";
    }
}

3.接口的静态方法

Java 8也允许在接口中定义静态方法，这些方法可以直接通过接口名调用。

public interface Vehicle {
    static void displayVersion() {
        System.out.println("Vehicle Interface v1.0");
    }
}

// 调用方式
Vehicle.displayVersion();

4.接口的多重继承

Java不支持类的多重继承，但一个类可以实现多个接口，从而获得多重继承的效果。

public interface Electric {
    void charge();
}

public class ElectricCar implements Vehicle, Electric {
    // 必须实现所有接口方法
}