• Java-面向对象(继承)


    继承

    什么是继承?

    继承是面向对象的三大特征之一,多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可。

    如何实现继承?

    Java中使用extends关键字实现类的继承机制,其语法规则为:

    class 子类名 extends 父类名{}

    • 通过继承,子类自动拥有父类(基类)放入所有成员(成员变量和方法)。
    • Java只支持单继承,不孕育多继承:一个子类只能有一个父类,一个父类可以派生出多个子类。

    示例

    //父类Person
    class Person{
        private String name;
        private int age;
        public void setName(String name){
            this.name = name;
        }
        public void setAge(int age){
            this.age = age;
        }
        public String getName(){
            return name;
        }
        public int getAge(){
            return age;
        }
    }
    //子类Student
    class Student extends Person{
      private String school;
      public String getSchool(){
          return school;
      }
      public void setSchool(String school){
          this.school=school;
      }
    }
    
    public class TestPerson {
        public static void main(String arg[]){
            Student s = new Student();
            s.setName("John");
            s.setAge(18);
            s.setSchool("SCH");
            System.out.println(s.getName());
            System.out.println(s.getAge());
            System.out.println(s.getSchool());
        }
    }
    

    权限修饰符(private、default、protected、public)

    • Java权限修饰符置于类的成员定义前,用来限定其他对象对该类对象成员的访问权限。
      • private私有的;
      • default默认的;
      • protected受保护的;
      • public公共的;
    修饰符类内部同一个包子类任何地方
    privateY
    defaultYY
    protectedYYY
    publicYYYY
    • 对于class的权限修饰只可以用public和default
      • public类可以在任意地方被访问
      • default类只可以在同一个包内部的类访问

    方法的重写

    什么是方法重写

    方法重写就是子类中出现了和父类中一模一样的方法声明,也可称为方法覆盖,方法复写。例:如果父类是鸟类,鸟类中有飞翔的方法,子类是鸵鸟,父类中飞翔的方法子类不适用,所以鸵鸟类就要重写飞翔这个方法。

    方法重写的注意事项

    • 重写方法必须和被重写方法具有相同的方法名称、参数列表和返回类型
    • 重写方法不能使用比被重写方法更严格的访问权限,也就是子类的权限不能比父类的权限级别低,最好权限一致。
    • 父类中私有的方法不能被重写,因为父类私有方法子类根本就无法继承。

    super关键字

    当父类中的方法被子类的方法覆盖,子类的对象将无法访问父类中被覆盖的方法,但是在子类方法中可以调用父类中被覆盖的方法。使用super关键字或者父类类名作为调用者来调用父类中被覆盖的方法。(父类类名作为调用者时,需考虑权限)

    class FatherClass{
        public int value;
        public void f(){
            value = 100;
            System.out.println("FatherClass.value="+value);
        }
    }
    class ChildClass extends FatherClass{
        public int value;
        public void f() {
            super.f();
            value = 200;
            System.out.println("ChildClass.value=" + value);
            System.out.println(value);
            System.out.println(super.value);
        }
    }
    public class TestInherit {
        public static void main(String arg[]) {
            ChildClass c = new ChildClass();
            c.f();
        }
    }
    
    输出:
    FatherClass.value=100
    ChildClass.value=200
    200
    100
    

    继承中的构造方法

    • 子类的构造过程中必须调用其父类的构造方法
    • 子类可以在自己的构造方法中使用super(argument_list)调用父类的构造方法。
      • 使用this(argument_list)调用本类的另外的构造方法
      • 如果调用super,必须写在子类构造方法的第一行
    • 如果子类的构造方法中没有显示调用父类构造方法,则系统默认调用无参数的构造方法
    • 如果子类的构造方法中既没有显示调用父类构造方法,而父类中又没有无参数的构造方法,则编译出错
    class SuperClass {
        private int n;
    
        SuperClass() {
            System.out.println("SuperClass()");
        }
      
        SuperClass(int n) {
            System.out.println("SuperClass(" + n + ")");
            this.n = n;
        }
    }
    
    class SubClass extends SuperClass {
        private int n;
        
        SubClass(int n) {
            //super();  //默认
            this();
            System.out.println("SubClass(" + n + ")");
            this.n = n;
        }
        
        SubClass() {
            super();
            System.out.println("SubClass()");
        }
    }
    
    public class TestSuperSub {
        public static void main(String arg[]) {
            //SubClass sc1 = new SubClass();
            SubClass sc2 = new SubClass(400);
        }
    }
    
    输出:
    SuperClass()
    SubClass()
    SubClass(400)
    

    例:构造函数与一般成员函数比较

    class A {
        protected void print(String s){
            System.out.println(s);
        }
        A(){print("A()");}
        public void f(){print("A:f()");}
    }
    class B extends A{
        B(){print("B()");}
        public void f(){print("B:f()");}
        public static void main(String arg[]){
            B b = new B();  //输出:A() B()  子类构造函数默认调用父类无参的构造方法
            b.f();          //输出:B:f()
        }
    }
    

    例2

    package TestPersonExtend;
    class Person{
        private String name;
        private String location;
    
        Person(String name){
            this.name = name;
            location = "beijing";
        }
        Person(String name,String location){
            this.name = name;
            this.location = location;
        }
        public String info(){
            return "name:"+name+";"+"location:"+location;
        }
    }
    
    class Student extends Person {
        private String school;
        Student(String name,String school){
            this(name,"beijing",school);
        }
        Student(String n,String l,String school){
            super(n,l);
            this.school = school;
        }
        public String info(){
            return super.info()+";"+"school:"+school;
        }
    }
    
    class Teacher extends Person {
        private String professional;
        Teacher(String name,String professional){
            this(name,"beijing",professional);
        }
        Teacher(String n,String l,String professional){
            super(n,l);
            this.professional= professional;
        }
        public String info(){
            return super.info()+";"+"professional:"+professional;
        }
    }
    
    public class Test {
        public static void main(String[] args){
            Person p1 = new Person("A");
            Person p2 = new Person("B","shanghai");
            Student s1 = new Student("C","s1");
            Student s2 = new Student("C","shanghai","s2");
            Teacher t1 = new Teacher("D","professor");
            System.out.println(p1.info());
            System.out.println(p2.info());
            System.out.println(s1.info());
            System.out.println(s2.info());
            System.out.println(t1.info());
        }
    }
    
    
  • 相关阅读:
    14:00面试,14:06就出来了,问的问题有点变态。。。
    CPP 核心编程9-STL
    vue3 setup写法(语法糖版本)
    安全防御设备---防火墙2
    Python学习笔记--多线程编程
    RabbitMQ 模拟实现【五】:网络通信设计
    leetcode 64. 最小路径和
    Python的命令行参数
    JavaSE => 类和对象 (二)
    大数据技术学习笔记(五)—— MapReduce(1)
  • 原文地址:https://blog.csdn.net/qq_43273590/article/details/126944550