Java特性

目录

1.封装

Java修饰符

2.继承

分类

super关键字

重载与重写的区别

3.多态

接口与抽象类的区别

---

面向对象三大特性：封装，继承，多态

1.封装

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。

 Java封装的主要作用是保护数据安全和提高代码的可维护性‌。‌

一个简单例子：实体类的封装

public class User {
    //属性的封装
    private String name;
    private String age;
    
    //方法的封装
    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

Java修饰符

1.public：最高访问权限，被public修饰的类、接口、方法、变量等可以被其他任何包内的其他类或方法访问

2.protected：受保护访问权限，被protected修饰的成员只能被相同包内或子类中的类或对象访问

3‌.private：私有访问权限，被private修饰的成员只能在其定义所在类内部被访问

    public String name;
    protected Integer phone;
    private String age;

2.继承

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

‌Java继承的主要作用包括代码重用、‌可扩展性、‌实现多态性、‌建立类层次结构和方法覆盖‌。‌

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

    //父类：Animal，都具有name变量，eat的方法
    public class Animal {
        String name;
        public void eat() {
            System.out.println(name + " 正在进食");
        }
    }

 子类继承了父类的属性与方法：

    //继承了父类的成员变量与方法
    public class Dog extends Animal {

    }

可以添加新的属性与方法

    //添加新的sleeping方法
    public class Dog extends Animal {
        public void sleeping() {
            System.out.println(name + " 正在睡觉");
        }
    }

通过super关键字访问父类的成员，重写父类中的方法

    //重写父类的方法
    public class Dog extends Animal {
        @Override
        public void eat() {
            super.eat();
            System.out.println(name + "还在进食");
        }
    }

实现父类的抽象方法

    //使用abstract关键字定义抽象类
    public abstract class Animal {
        public abstract void eat();
    }

    //实现父类的抽象类
    public class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("依旧在进食");
        }
    }

分类

单继承：一个类只能有一个直接父类

多层继承：一个子类可以有一个子子类，可以多级继承

super关键字

• ‌调用父类构造方法‌：‌在子类的构造方法中，‌可以使用super关键字调用父类的构造方法，‌以确保父类被正确初始化。‌
• ‌访问父类成员变量和方法‌：‌当子类需要访问或调用父类中定义的成员变量或方法时，‌可以使用super关键字来实现。‌
• ‌解决歧义‌：‌在子类重写父类方法的情况下，‌如果需要调用父类中的原始方法，‌可以使用super关键字来消除歧义。‌

重载与重写的区别

1. 定义不同‌：‌重载是在同一个类中定义多个同名方法，‌但参数列表不同；‌重写是子类对父类中已存在的方法进行重新定义。‌

2. 范围不同‌：‌重载发生在同一个类中；‌重写发生在子类与父类之间。‌

3. ‌多态性不同‌：‌重载是编译时的多态性；‌重写是运行时的多态性。‌

4. 参数列表‌：‌重载要求参数列表不同（‌参数个数、‌类型或顺序）‌；‌重写要求参数列表完全相同。‌

5. 访问修饰符‌：‌重载对访问修饰符没有特殊要求；‌重写要求子类方法的访问修饰符不能比父类方法更严格。‌

3.多态

多态（Polymorphism）是面向对象编程中一个核心概念。简单来说，多态是允许不同类的对象对同一消息做出响应的能力。

实现方式：

1.方法重载：在同一个类中，多个同名方法可以有不同的参数列表，即参数的类型、数量或顺序不同。

void method(int param) {
    System.out.println(param);
}

void method(String param) {
    System.out.println(param);
}

2.方法覆盖： 子类可以提供与父类完全相同的方法，从而允许子类定义特定的行为。

class Parent {
    void print() {
        System.out.println("父类");
    }
}

class Child extends Parent {
    @Override
    void print() {
        System.out.println("子类");
    }
}

3.接口：一个类可以实现一个或多个接口，从而不必实现接口中的所有方法。

public interface Inter {
    void print();
}

public class Impl implements Inter {
    @Override
    public void print() {
        System.out.println("实现类");
    }
}

4.抽象类和抽象方法：

public abstract class Shape {
    abstract void draw();
}

public class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("实现方法");
    }
}

接口与抽象类的区别

• ‌方法实现‌：‌抽象类中可以包含抽象方法和非抽象方法，‌即可以有方法的实现；‌而接口中的所有方法都是抽象的，‌没有方法体，‌只有方法签名。‌
• ‌构造方法‌：‌抽象类可以有构造方法，‌用于子类实例化时初始化；‌接口不能有构造方法。‌
• ‌成员变量‌：‌抽象类中的成员变量可以是各种类型的，‌包括私有、‌保护、‌公开等；‌接口中的成员变量默认是public static final的，‌即公开的静态常量。‌
• ‌继承与实现‌：‌一个类只能继承一个抽象类，‌但可以实现多个接口，‌这是接口提供的一种多继承的机制。‌