SE

1、三大特性

1.1封装

通过private关键字将属性私有。
提供公有get、set方法获取或修改。

1.2继承

继承通过extends关键字，java支持单继承。
子类可添加特有属性。
子类通过super关键字访问父类属性（不能继承父类私有成员和构造方法）。

1.3多态

多态

父类引用指向子类对象。
存在继承关系。
子类重写父类方法。

public abstract class Pet{
    String name;
    public Pet(String name) {
        this.name = name;
    }
    public abstract void run();
}
class Dog extends Pet{
    private int leg = 4;
    public Dog(String name) {
        super(name);
    }
    public void run() {
        System.out.println(name+"是小狗，所以它用"+leg+"条腿跑。");
    }
}
class Dove extends Pet{
    private int leg = 2;
    public Dove(String name) {
        super(name);
    }
    public void run(){
        System.out.println(name+"是鸽子，它有"+leg+"条腿，所以他会飞。");
    }
}
public class Test {
    public static void main (String[] args) {
    Pet dog = new Dog("旺财");
    Pet dove = new Dove("来财");
    dog.run();
    dove.run();
    }
}

*运行时实际调用的内容由引用类型决定而非引用对象决定。在继承中如果存在调用同名成员变量或者静态方法时，输出的内容实际是父类的变量或者方法。如果是普通的成员方法，实际执行的就是引用对象的方法。

实现多态的方式

子类重写父类方法。
抽象类+抽象方法。
父类定义接口子类实现。

意义

减少代码量。

提高代码可拓展性和可维护性。

1.4抽象

抽象类定义必须用abstract关键字修饰，且不能被实例化。
抽象方法必须定义在抽象类或接口内部。
抽象方法没有方法体。
抽象方法必须在子类实现。

2、类

2.1类的静态成员

特征

所有对象公有。
没有创建对象也可访问。
可以是属性或者方法。
不可以在实例方法中使用。

3、方法

3.1重载

方法名相同
属性的类型或者个数不同

public class Pet{
    private String type;
    private String name;
    private String food;
    public static void main (String[] args) {
        Pet p1 = new Pet();
        Pet p2 = new Pet();
        p2.name = "旺财";
        p2.food = "骨头";
        p1.eat("小狗", "花花", "骨头");
        p2.eat("旺财", "狗粮");
    }
    public void eat(String name,String food) {
            System.out.println(name+"正在吃"+food);
    }
    public void eat(String type,String name,String food) {
        System.out.println(type+name+"正在啃"+food);
    }
}

3.2重写

方法名相同。
参数列表相同。
返回值的类型不同或内容不同。

class Phone {
    public void showNumber() {
        System.out.println("显示号码");
    }
}

class SmartPhone extends Phone {
    // 重写
    @Override 
    public void showNumber() {
        super.showNumber(); // 先让父类（显示号码）
        System.out.println("显示头像"); // 实现子类
        System.out.println("显示归属地");
    }
}

重写equals方法

public class User {
    private int id;
    private String name;

    @Override
    public boolean equals(Object obj) {
        // 1. 自反性：如果是同一个实例，直接返回 true
        if (this == obj) return true;

        // 2. 非空判断：如果传入对象为 null，直接返回 false
        if (obj == null) return false;

        // 3. 类型检查：判断传入对象是否属于同一个类
        // 使用 getClass() 比 instanceof 更严格，防止继承导致的问题
        if (this.getClass() != obj.getClass()) return false;

        // 4. 强转类型：将 Object 转换为当前类类型
        User other = (User) obj;

        // 5. 属性比较：比较关键字段
        // 基本类型用 ==，引用类型用 Objects.equals() 防止 null 指针
        return this.id == other.id && 
               Objects.equals(this.name, other.name);
    }

    // ⚡️ 重要：重写 equals 必须重写 hashCode！
    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}

4、接口

支持多继承，一个类可以有多个接口。
不能实例化，不能有构造方法。
接口可以继承接口。
属性是全局静态属性，方法是全局抽象方法。

常见的运行时异常

1、空指针异常，引用指向null对象。

2、输入不匹配异常，要求输入整型输入字符串或浮点型。

3、类型转换异常，把一个对象转换为他不兼容的类型。

4、数组索引越界异常，访问数组的索引超出数组长度。

5、非法参数异常，传入的参数合法不合理，超出要求的参数范围。

try-catch-finally中，finally唯一不执行情况

有System.exit()输出/进程被外部强制中止。

posted @ 2026-01-03 22:06 coldmist 阅读(46) 评论(0) 收藏举报

刷新页面返回顶部

coldmist

SE

SE