java面向对象基础知识总结回顾继承的特性子类拥有父类非 private 的属性、方法。子类可以拥有自己的属性和方法

继承的特性

子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差)


//一个java文件中只能有一个public class
class People{
    private String name;
    private int age;
    public People(String name ,int age){
        this.name=name;
        this.age=age;
    }

    public void show(){
        System.out.println("我是父类");
        System.out.println("我是"+name+"今年"+age+"岁了");
    }

    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;
    }

    @Override
    public String toString() {
        return "{ name="+name+"," +
                " age="+age+"}";
    }
}


class Student extends People{
    private int id;
    private String major;
    public Student(String name,int age,int id,String major){
        super(name,age);
        this.id=id;
        this.major=major;
    }
    //重写父类方法

    public void show(){
        super.show();
        System.out.println("我是子类");
        System.out.println("我是"+getName()+"今年"+getAge()+"岁了，学号是"+id+"，专业是"+major);
    }
    public void detail(){
        System.out.println("学生");
    }

}

public class test01 {
    public static void main(String[] args) {
        People p=new People("xsp",22);
        System.out.println(p);

        //继承
        Student s=new Student("xsp",22,111,"计算机");
        
        s.show();
        //结果是：
        我是父类
        我是xsp今年22岁了
        我是子类
        我是xsp今年22岁了，学号是111，专业是计算机
       
        s.detail();
        
        //多态
        People t=new Student("xsp",22,111,"计算机");
        t.show(); //调用的应该是子类的show方法
        // t.detail(); 编译器会报错 因为t是People类型 People没有detail方法

        //如果想要使用t.detail() 需要向下转型
        if(t instanceof Student){
            Student stu=(Student) t;
            stu.detail();
        }
          
    }
}

super 与 this 关键字

super 关键字： 我们可以通过 super 关键字来实现对父类成员的访问，用来引用当前对象的父类。

this 关键字： 指向自己的引用，引用当前对象，即它所在的方法或构造函数所属的对象实例。

Super 关键字的使用

当需要在子类中调用父类的被重写方法时，要使用 super 关键字。

提问：

A是父类 B是子类 show()是类里面的方法 b是B创建的对象能不能使用b.super.show()

在 Java 中，子类的对象（例如 b 是 B 类的实例）不能使用 b.super.show() 的语法来调用父类 A 的方法 show()。super 关键字的使用方式与对象实例无关，而是与类的上下文相关。

正确使用 `super`

如果你想从子类 B 中调用父类 A 的 show() 方法，应该在 B 的方法内部使用 super，如下所示：

class A {
    void show() {
        System.out.println("Show from A");
    }
}

class B extends A {
    void show() {
        super.show(); // 调用父类 A 的 show 方法
        System.out.println("Show from B");
    }
}

public class Main {
    public static void main(String[] args) {
        B b = new B();
        b.show(); // 通过 b 调用 show 方法
    }
}

输出

Show from A
Show from B

总结

不能使用 b.super.show() ：这是不合法的语法。
使用 super.show() ：在子类的方法中可以使用 super 来调用父类的方法。
对象调用方法：你可以通过对象 b 调用 B 类的方法（如 b.show()），而在 show() 方法内部，可以使用 super 调用父类的方法。

构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

1.使用`super`调用父类构造函数

基本语法：
在子类的构造函数中，使用super()来调用父类的构造函数。可以在括号中传递参数，如果父类构造函数需要参数。
调用顺序：
super()必须是构造函数的第一行代码。

2.final 关键字

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。 final 含义为 "最终的"。使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，当fignal用于修饰方法，该方法不能被子类重写：

声明类：
```
final class 类名 {//类体}
```

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注： final 定义的类，其中的属性、方法不是 final 的。

多态

在Java中，以下代码行：

Animal b = new Dog();

解释

对象创建：

new Dog() 创建了一个 Dog 类的实例，Dog 是 Animal 类的子类。
引用类型：

在这个表达式中，b 的引用类型是 Animal。这意味着 b 可以调用 Animal 类中定义的方法和属性。
实际对象类型：
- 实际上，b 引用的是一个 Dog 类型的对象。这意味着虽然 b 的类型是 Animal，但它实际上指向的是一个 Dog 实例。

多态性

这种结构展示了Java中的多态性特征：

可以用父类类型的引用来指向子类的对象。
通过父类引用调用的方法，如果在子类中被重写，则会执行子类的方法。

示例代码

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

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal b = new Dog(); // b 是 Animal 类型，但指向 Dog 对象
        b.sound(); // 调用 Dog 的 sound 方法
    }
}

输出结果

Dog barks

总结

在上面的例子中可以看到，尽管 b 属于 Animal 类型，但是它运行的是 Dog 类的 sound方法。
这是由于在编译阶段，只是检查参数的引用类型。
然而在运行时，Java 虚拟机(JVM)指定对象的类型并且运行该对象的方法。
因此在上面的例子中，之所以能编译成功，是因为 Animal 类中存在 sound 方法，然而运行时，运行的是特定对象的方法。
b 的引用类型是 Animal。
运行时，实际调用的是 Dog 类中重写的方法，表现出多态性。

方法的重写规则

参数列表与被重写方法的参数列表必须完全相同
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个类，则不能重写该类的方法。

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

示例代码

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

java面向对象基础知识总结回顾

继承的特性

super 与 this 关键字

Super 关键字的使用

正确使用 super

输出

总结

构造器

1.使用super调用父类构造函数

2.final 关键字

多态

在Java中，以下代码行：

解释

多态性

示例代码

输出结果

总结

方法的重写规则

重载(Overload)

示例代码

重写与重载区别

正确使用 `super`

1.使用`super`调用父类构造函数