zoukankan      html  css  js  c++  java
  • Java从零开始学十五(继承)

    一、继承作用

    继承使用复用以前的代码非常容易,能够大大的缩短开发周期,降低开发成本,同时增加程序的易维护性

    继承使重一个类A能够直接使用另外一个类B的属性和方法的一种途径

    类A可以有自己的属性和方法

    二、继承实现

    类的继承格式
    在Java中使用extends关键字完成类的继承关系,操作格式:
    class 父类{} // 定义父类
    class 子类 extends 父类{} // 使用extends关键字实现继承
    package com.pb.person;
    /*
     * 父类
     */
    public class Person {
        private String name; //姓名
        private String sex;    //性别
        private int age;//年龄
    
        //设置getter和setter方法
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getSex() {
            return sex;
        }
        public void setSex(String sex) {
            if(sex.equals("男") || sex.equals("女")){
                //设置性别限制,不合法的值将提示错误
            this.sex = sex;
            }else{
                System.out.println("性别不合法,性别只能是:男或者女");
            }
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            if(age>0 && age<=150){
                //设置年龄限制
            this.age = age;
            }else{
                System.out.println("年龄只能在1-150岁之间");
            }
        }
        public Person() {
            this.name = "无名氏";
            this.sex = "男";
            this.age = 22;
        }
        public Person(String name, String sex, int age) {
            this.name = name;
            this.sex = sex;
            this.age = age;
        }
        
        public void say(){
            System.out.println("自我介绍:");
            System.out.println("姓名:"+this.name);
            System.out.println("性别:"+this.sex);
            System.out.println("年龄:"+this.age);
        }
    
    }

    子类:

    package com.pb.person;
    /*
     * 子类
     */
    public class Student extends Person {
        private int stuNo ;   //学号
        private String specialty;   //专业
        
        public Student() {
    
        }
        public Student(String name, String sex, int age,int stuNo,String specialty) {
            super(name, sex, age);
            this.stuNo=stuNo;
            this.specialty=specialty;
        }
        
        
        //getter/setter方法
        public int getStuNo() {
            return stuNo;
        }
        public void setStuNo(int stuNo) {
            this.stuNo = stuNo;
        }
        public String getSpecialty() {
            return specialty;
        }
        public void setSpecialty(String specialty) {
            this.specialty = specialty;
        }
        
        
        
    
    }

    测试类

    package com.pb.persontest;
    
    import com.pb.person.Student;
    
    public class Test {
    
        public static void main(String[] args) {
            Student stu=new Student("张三", "男", 22, 121, "计算机科学与技术") ;
            stu.say();
    
        }
    
    }

    结果:

    自我介绍:
    姓名:张三
    性别:男
    年龄:22

    以下可以发现,子类的学号,和专业并没有输出,

    默认调用的父类的say()方法

    需要子类重写父类的方法

    三、方法的重写

    方法的重写是发生的子类对父类的过程中,是在2个类中,和方法重载是在一个类中

    方法重写有以下要求

    Student类重写Person类中的say()方法

    package com.pb.person;
    /*
     * 子类
     */
    public class Student extends Person {
        private int stuNo ;   //学号
        private String specialty;   //专业
        
        public Student() {
    
        }
        public Student(String name, String sex, int age,int stuNo,String specialty) {
            super(name, sex, age);
            this.stuNo=stuNo;
            this.specialty=specialty;
        }
        //方法重写
        @Override
        public void say() {
        
            super.say();
            System.out.println("学号是:"+this.stuNo);
            System.out.println("专业是:"+this.specialty);
        }
        
        //getter/setter方法
        public int getStuNo() {
            return stuNo;
        }
        public void setStuNo(int stuNo) {
            this.stuNo = stuNo;
        }
        public String getSpecialty() {
            return specialty;
        }
        public void setSpecialty(String specialty) {
            this.specialty = specialty;
        }
        
        
        
    
    }

    测试类不变:

    package com.pb.persontest;
    
    import com.pb.person.Student;
    
    public class Test {
    
        public static void main(String[] args) {
            Student stu=new Student("张三", "男", 22, 121, "计算机科学与技术") ;
            stu.say();
    
        }
    
    }

    结果:

    自我介绍:
    姓名:张三
    性别:男
    年龄:22
    学号是:121
    专业是:计算机科学与技术

    重写以后,调用的就是子类重写后的方法

     四、super关键字

    super必须是出现在子类中(子类的方法和构造方法中),而不是其他位置,在构造方法中必须出现在第一行

    用以访问父类的成员,例如:父类的属性、方法、构造方法

    访问权限的限制,例如无法通过super访问private成员

    五、继承条件下构造方法的调用规则

    规则一:如果子类的构造方法中没有通过super显示调用父类的有参构造方法,也没有通过this显式调用自身的其他构造方法,则系统会默认先调用父类的无参构造方法

    规则二:如果子类的构造方法中通过super显示调用父类的有参构造方法,那将执行父类的相应的构造方法,而不执行父类无参数构造方法

     规则三:如果子类的构造方法中通过this显式调用自身的其他构造方法,在相应构造方法中应用以上2条规则

    5.1、例一

    package compb.demo4;
    /*
     * 父类
     */
    public class StaticSuper {
        public static String staticGet() {
            return "父类静态方法";
        }
    
        public String dynamicGet() {
            return "父类动态方法";
        }
    }
    
    package compb.demo4;
    /*
     * 子类
     */
    public class StaticSub  extends StaticSuper{
        
        //静态方法不能重写
        public static String staticGet() {
            return "子类静态方法";
        }
        @Override
        public String dynamicGet() {
            return "子类动态方法重写父类动态方法";
        }
    
    }
    
    package compb.demo4;
    /*
     * 测试
     */
    public class Test {
    
        public static void main(String[] args) {
            StaticSub s= new StaticSub();  //声明子类对象
        System.out.println(s.staticGet());   //调用子类静态方法
            System.out.println(s.dynamicGet());  //调用子类动态方法
        }
    
    }

    结果:

    子类静态方法
    子类动态方法重写父类动态方法

    5.2、例二、

    package com.pb.demo5;
    /*
     * 父类
     */
    public class VenderLate {
    
        public VenderLate() {
            System.out.print("VenderLate out");
        }
        
    }
    package com.pb.demo5;
    
    public class MoveGoods  extends VenderLate{
    
        public MoveGoods( ) {
            System.out.println("MoveGoods out!");
            }
        
        public MoveGoods(String s) {
        System.out.println(s);
        }
        
        
    }
    package com.pb.demo5;
    /*
     * 测试类
     */
    public class Test {
    
        public static void main(String[] args) {
            MoveGoods m=new MoveGoods();
            MoveGoods g=new MoveGoods("   child");
        
        
    
        }
    
    }

    结果:

    VenderLate outMoveGoods out!
    VenderLate out child

    5.3 、例三

    package com.pb.demo4;
    /*
     * 父类
     */
    public class SuperClass {
        private String name;
    
        public SuperClass() {
        System.out.println("父类的无参数构造方法");
        }
        public SuperClass(String name) {
            System.out.println("父类有一个参数的构造方法:"+name);
            }
        //setter/getter方法
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        
    }

    子类

    package com.pb.demo4;
    
    public class SubClass extends SuperClass {
     private String name;
     private int count;
     
        public SubClass() {
            System.out.println("子类无参数构造方法");
        }
        public SubClass(int count) {
            System.out.println("子类有一个参数构造方法:"+count);
        }
        
        //调用父类有参数的构造方法
        public SubClass(String name) {
            super(name);
            this.name=name;
            System.out.println("调用子类有一个参数构造方法,同时使用super显示调用"+name);
        }
    
    //setter/getter方法
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
        public int getCount() {
            return count;
        }
        public void setCount(int count) {
            this.count = count;
        }
    
    }

    测试类:

    package com.pb.demo4;
    
    public class Test {
    
        public static void main(String[] args) {
            System.out.println("*******调用子类无参数构造方法**********");
            SubClass s1=new SubClass();
            System.out.println("*******调用子类有一个参数构造方法但是没有使用super显示调用**********");
            SubClass s2=new SubClass(34);
            System.out.println("*******调用子类有一个参数构造方法,同时使用super显示调用**********");
            SubClass s3=new SubClass("张三");
        }
    
    }

    结果:

    *******调用子类无参数构造方法**********
    父类的无参数构造方法
    子类无参数构造方法
    *******调用子类有一个参数构造方法但是没有使用super显示调用**********
    父类的无参数构造方法
    子类有一个参数构造方法:34
    *******调用子类有一个参数构造方法,同时使用super显示调用**********
    父类有一个参数的构造方法:张三
    调用子类有一个参数构造方法,同时使用super显示调用张三

     六、Object类

    所有的有类都自动继承java.lang包中的Object类

    Object类是所有类的父类(基类)

    在定义一个类时如果没有使用extends关键字,则默认继承Object类

    Object常被重写的方法:

  • 相关阅读:
    Ubuntu配置sublime text 3的c编译环境
    ORA-01078错误举例:SID的大写和小写错误
    linux下多进程的文件拷贝与进程相关的一些基础知识
    ASM(四) 利用Method 组件动态注入方法逻辑
    基于Redis的三种分布式爬虫策略
    Go语言并发编程总结
    POJ2406 Power Strings 【KMP】
    nyoj 会场安排问题
    Server Tomcat v7.0 Server at localhost was unable to start within 45 seconds. If the server requires more time, try increasing the timeout in the server editor.
    Java的String、StringBuffer和StringBuilder的区别
  • 原文地址:https://www.cnblogs.com/liunanjava/p/4295225.html
Copyright © 2011-2022 走看看