java笔记4

7.封装

封装是面向对象编程的四大基本特性之一，它将对象的数据（属性）和行为（方法）组合在一起，并隐藏内部的实现细节。

何为封装

• 封装是创建对象的过程，确保对象的内部状态只能通过对象提供的方法来访问和修改。

访问修饰符

private 关键字

• private修饰的成员只能在类的内部访问，不能被类的外部访问。

public 关键字

• public修饰的成员可以被任何其他类访问。

Getter 访问器 和 Setter 修改器

• Getter：返回对象的私有属性值的方法。
• Setter：设置对象的私有属性值的方法。

作用

• 封装属性，提供访问和修改私有属性的接口。

this 关键字

• this代表当前对象的引用，有以下用法：
  1. 引用当前类的属性或方法。
  2. 区分成员变量和局部变量。
  3. 在构造器中调用另一个构造器。
  4. 访问当前对象的实例方法。
  5. 返回当前对象的实例。

static 关键字

• static表示属于类而非类的实例。

静态变量

• 属于类的所有实例共享的变量。

静态方法

• 属于类的所有实例共享的方法，可以通过类名直接调用。

静态代码块

• 在类加载时执行的代码块，用于初始化静态资源。

jar包

• Java归档包，用于分发Java类库。

第三方类库

• 通过将第三方库打包成jar文件，可以在Java项目中引入和使用。

示例代码

复制代码

// 封装的示例：定义一个Person类
public class Person {
    // 私有属性
    private String name;
    private int age;

    // 公共构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter和Setter方法
    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;
    }

    // 实例方法
    public void introduce() {
        System.out.println("Hello, my name is " + this.name + " and I am " + this.age + " years old.");
    }

    // 静态方法
    public static void greet() {
        System.out.println("Hello, this is a static method.");
    }

    // 静态代码块
    static {
        System.out.println("Static block is being initialized.");
    }
}

// 使用Person类
public class Main {
    public static void main(String[] args) {
        // 使用公共构造器实例化对象
        Person person = new Person("Alice", 30);

        // 使用Getter和Setter
        person.setName("Bob");
        person.setAge(25);
        System.out.println(person.getName() + " is " + person.getAge());

        // 调用实例方法
        person.introduce();

        // 调用静态方法
        Person.greet();

        // 静态变量和静态代码块在类被加载时初始化
    }
}

8.继承

继承是面向对象编程的四大基本特性之一，它允许新创建的类（子类）继承现有类（父类）的属性和方法。

何为继承

• 继承是从已有的类派生出新类的过程，新类会继承父类的属性和方法，并能添加新的属性和方法或重写父类的方法。

继承的优点和缺点

优点

• 代码复用：减少代码冗余，提高开发效率。
• 层次结构：清晰地组织和管理类之间的关系。
• 多态性：通过继承实现多态，使代码更灵活。

缺点

• 耦合性：子类与父类耦合，父类的变更可能影响子类。
• 脆弱性：继承结构可能导致代码脆弱，难以维护。
• 限制性：限制了子类的扩展方式，只能继承一个父类（单继承）。

Object类

Java中的所有类都隐式地继承自Object类，它位于类继承层次结构的顶端。

常用的方法

• equals(Object obj)：检查两个对象是否相等。
• hashCode()：返回对象的哈希码。
• toString()：返回对象的字符串表示。
• clone()：创建并返回对象的副本。

方法重写

方法重写（Override）是子类覆盖父类中已有的方法的行为。

方法重写规则

• 子类方法必须和父类被重写的方法具有相同的方法名、返回类型和参数列表。
• 子类方法的访问权限不能比父类方法的访问权限更严格。
• 子类方法不能抛出新的检查异常或更广泛的异常。

方法重写与方法重载的区别

• 方法重写：发生在继承体系中，是子类对父类方法的覆盖。
• 方法重载：是同一个类中多个同名方法，但参数列表不同。

super关键字

super关键字用于访问父类的属性、方法和构造器。

用法

• 访问父类的成员变量或方法。
• 调用父类的构造器：super(); 或 super(param);。

final关键字

final关键字表示一个实体不可被修改或覆盖。

用法

• 修饰类：表示该类不可被继承。
• 修饰方法：表示该方法不可被重写。
• 修饰变量：表示该变量一旦被初始化后，值就不能被改变。

示例代码

复制代码

// 父类
class Animal {
    void eat() {
        System.out.println("Animal eats food.");
    }
}

// 子类继承自父类
class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("Dog eats meat.");
    }

    void bark() {
        System.out.println("Dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 方法重写的例子
        dog.bark(); // 子类特有的方法

        // 使用super调用父类的方法或构造器
        System.out.println("The Object class method: " + dog.toString());
    }
}