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的,‌即公开的静态常量。‌
  • 继承与实现‌:‌一个类只能继承一个抽象类,‌但可以实现多个接口,‌这是接口提供的一种多继承的机制。‌

你可能感兴趣的:(java,开发语言)