您当前的位置： 首页 >  Java

Java学习路线-5：继承

彭世瑜 发布时间：2019-10-26 23:38:52 ，浏览量：2

第12 章 ： 继承的定义与使用 59 继承问题引出

继承：扩充已有类的功能

60 继承的实现 
class 子类 extends 父类

子类：派生类 父类：超类

继承实现的主要目的 子类可以重用父类中的结构，并且扩充功能

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 this.name ;
    }

    public int getAge(){
        return this.age ;
    }

    public Person(String name, int age){
        this.name = name ;
        this.age = age ;
    }

}


class Student extends Person{
    String school ;

    public void setSchool(String school){
        this.school = school ;
    }
    
    public String getSchool(){
        return this.school ;
    }

    public Student(String name, int age, String school){
        super(name, age);
        this.school = school ;
    }
}

class Demo{
    public static void main(String[] args) {
        Student student = new Student("张三" , 23, "大学");
        
        System.out.println(student.getName());
        // 张三

        System.out.println(student.getSchool());
        // 大学
    }
}
61 子类对象实例化流程

子类实例化会自动调用父类构造方法

默认执行 super()

子类构造方法默认调用父类无参构造方法，只允许放在子类构造方法首行

结论： 定义类的时候最好写无参构造方法 实例化子类对象的同事一定会实例化父类对象


class Person{
    private String name ;
    private int age ;
    
    public Person(){}

    public Person(String name, int age){
        this.name = name ;
        this.age = age ;
    }

}


class Student extends Person{
    public Student(String name, int age){
        super(name, age); // 调用父类构造方法
    }
}

class Demo{
    public static void main(String[] args) {
        Student student = new Student("张三" , 23);
    }
}

super, this 两个语句不能同时出现 相同点： 1、都可以调用构造方法 2、都只能放在构造方法首行

不同点： 1、super 调用父类构造方法 2、this 调用本类构造方法

62 继承定义限制

Java不允许多重继承，只允许多层继承

多重继承

class A{}
class B{}
class C extends A, B{}

多层继承, 一脉传承

class A{}
class B extends A{}
class C extends B{}

继承关系最好不要超过三层

子类可以继承父类中所有操作结构 显式继承非私有操作 隐式继承私有操作

class Person{
    private String name ;
    
    public String getName(){
        return this.name ;
    }

    public Person(){}

    public Person(String name){
        this.name = name ;
    }
}


class Student extends Person{
    public void fun(){
        // 错误, 子类不能访问父类中的私有属性
        // System.out.println(this.name); 

        // 子类间接访问父类中的私有属性
        System.out.println(this.getName());  
        // 张三
    }

    public Student(String name){
        super(name);
    }
}

class Demo {
     public static void main(String[] args) {
        Student student = new Student("张三");
        student.fun();
    }
}
63 方法覆写

覆写意义：优化功能

子类调用父类方法 super.方法()

调用本类方法, this可省略 this.方法()


class Resource{
    public void connect(){
        System.out.println("资源连接");
    } 
}


class Database{
    public void connect(){
        System.out.println("数据库资源连接");
    }

}


class Demo{
    public static void main(String[] args) {
        Database db = new Database();
        
        // 调用子类的方法
        db.connect();  
        // 数据库资源连接
    }
}
64 方法覆写限制

覆写的方法访问控制权限要 大于等于 父类方法控制权限

访问权限控制 public > default(不写) > private

区别Override Overloading

Override 覆写 概念：方法名，签名（参数类型，个数），返回值相同 权限：被覆写的方法不能有更严格的权限控制 范围：发生在继承关系中

Overloading 重载 概念：方法名相同，签名（参数类型，个数）不同，推荐返回类型一致 权限：没有权限控制 范围：发生在一个类中

65 属性覆盖

属性覆盖：子类定义了与父类相同名称的成员

区别：this super this 先查找本类，再查找父类，this可以表示本类对象 super 直接查找父类


class Father{
    private String name = "Father" ;

}

class Child{
    private String name = "Child" ;
    
    public String getName(){
        return this.name;
    }
}

class Demo{
    public static void main(String[] args) {
        Child child = new Child();
        System.out.println(child.getName()) ;
        // Child
    }
    
}
66 final关键字

final 定义不能被继承的类，不能被覆写的方法，常量

final class Demo{}  // 不能有子类

class Demo{
    public final void fun(){}  // 不能被覆写
} 

class Demo{
    private final int ON = 1 ;  // 常量不能被重新赋值
    private final int OFF = 0 ; 
}

常量往往都是公共的，全局常量

public static final int ON = 1 ;
public static final int OFF = 0 ;

常量每个字符都必须大写

67 案例分析一（学生类）

简单Java类

学生类继承人类 人类 -四个属性：name，address， sex， age -三个构造：四参，两参，无参 -一个方法：显示输出

学生 -增加两个属性：math，english -三个构造：六参，两餐，无参 -一个重写方法：显示输出

class Person{
    private String name ;
    private int age ;
    private String address;
    private char sex;

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

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

    public void setAddress(String address){
        this.address = address ;
    }

    public void setSex(char sex){
        this.sex = sex ;
    }

    public String getName(){
        return this.name ;
    }

    public int getAge(){
        return this.age ;
    }

    public String getAddress(){
        return this.address ;
    }

     public char getSex(){
        return this.sex ;
    }

    public Person(){}

    public Person(String name, int age){
        // 调用本类构造方法
        this(name, age, "", '男');
    }

    public Person(String name, int age, String address, char sex){
        this.name = name ;
        this.age = age ;
        this.address = address ;
        this.sex = sex ;
    }

    public String getInfo(){
        return "name: " + this.name + 
                " age: " + this.age +
                " address: " + this.address + 
                " sex: " + this.sex ;
    }
}


// 继承
class Student extends Person{
    private double math ;
    private double english ;

    public void setMath(double math){
        this.math = math ;
    }

    public void setEnglish(double english){
        this.english = english ;
    }
    
    public double getMath(){
        return this.math ;
    }

     public double getEnglish(){
        return this.english ;
    }

    // 重载构造方法
    public Student(){}


    public Student(String name, int age){
        // 调用父类构造方法
        super(name, age);
    }

    public Student(String name, int age, String address, char sex, 
        double math, double english){
        super(name, age, address, sex);
        this.math = math ;
        this.english = english ;
    }

    // 覆写父类方法
    public String getInfo(){
        return super.getInfo() + 
                " math: " + this.math +
                " english: " + this.english ;
    }
}

class Demo{
    public static void main(String[] args) {
        Student student = new Student("张三", 16, "北京", '男', 99.9, 87.9);
        System.out.println(student.getInfo());
        // name: 张三 age: 16 address: 北京 sex: 男 math: 99.9 english: 87.9

    }
}
68 案例分析二（管理人员与职员）

员工类 -2个属性 name, age -2个构造 无参, 2参 -1个方法 显示信息

普通职员 -4属性 name, age, dept, salary -2构造 无参， 4参 -1个方法 显示信息

管理人员 -4属性 name， age, position, income -2构造 无参， 4参 -1个方法 显示信息

class Employee{
    private String name ;
    private int age ;

    public Employee(){}

    public Employee(String name, int age){
        this.name = name ;
        this.age = age ;
    }

    public String getInfo(){
        return "name: " + this.name + " age: " + this.age ;
    }
}


class Stuff extends Employee{
    private String dept ;
    private double salary ;

    public Stuff(){}

    public Stuff(String name, int age, String dept, double salary){
        super(name, age);
        this.dept = dept ;
        this.salary = salary ;
    }

    public String getInfo(){
        return "【Stuff】 " + super.getInfo() + 
            " dept: " + this.dept + 
            " salary: " + this.salary;
    }
}


class Manager extends Employee{
    private String position ;
    private double income ;

    public Manager(){}

    public Manager(String name, int age, String position, double income){
        super(name, age);
        this.position = position ;
        this.income = income ;
    }

    public String getInfo(){
        return "【Manager】 " + super.getInfo() + 
            " position: " + this.position + 
            " income: " + this.income;
    }
}

class Demo{
    public static void main(String[] args) {
        Stuff stuff = new Stuff("张三", 23, "技术部", 3000.0);
        Manager manager = new Manager("李四", 32, "技术总监", 150000.0);

        System.out.println(manager.getInfo());
        // 【Manager】 name: 李四 age: 32 position: 技术总监 income: 150000.0

        System.out.println(stuff.getInfo());
        // 【Stuff】 name: 张三 age: 23 dept: 技术部 salary: 3000.0

    }
}
69 案例分析三（字符串统计）

统计 字符o 和 n 出现的次数 do you know?

方式一：返回数组


class CountDemo{
    // 统计两个字符个数，第一个为o, 第二个为u
    public static int[] getCount(String str){
        int[] countData = new int[2] ;

        char[] data = str.toCharArray() ;
        

        for(char c : data){
            if(c == 'o' || c == 'O'){
                countData[0] ++;
            }
            else if(c == 'u' || c == 'U'){
                countData[1] ++;
            }
        }
        
        return countData;
    }

    public static void main(String[] args) {
        int[] countData = CountDemo.getCount("are you ok?") ;
        
        System.out.println("o: " + countData[0]); // o: 2
        System.out.println("u: " + countData[1]); // u: 1
    }
}

方式二：返回对象

class StringUtil{
    private String content ; 

    public StringUtil(String content){
        this.content = content ;
    }

    public String getContent(){
        return this.content ;
    }
}


class CountDemo extends StringUtil {
    private int oCount = 0;
    private int uCount = 0;

    public CountDemo(String content){
        super(content) ;

        this.countChar() ;  //构造方法调用统计
    }

    // 统计两个字符个数
    public void countChar(){
    
        char[] data = super.getContent().toCharArray() ;
        
        for(char c : data){
            if(c == 'o' || c == 'O'){
                this.oCount ++;
            }
            else if(c == 'u' || c == 'U'){
                this.uCount ++;
            }
        }
    }

    public int getOCount(){
        return this.oCount ;
    }

     public int getUCount(){
        return this.uCount ;
    }

}

class Demo{
    public static void main(String[] args) {
        CountDemo countData = new CountDemo("are you ok?") ;
        
        System.out.println("o: " + countData.getOCount()); // o: 2
        System.out.println("u: " + countData.getUCount()); // u: 1
    }
}
70 案例分析四（数组操作）

1、实现数组保存数据 （1）大小由外部决定 （2）增加数据，满了则失败 （3）数组扩容 （4）取得数组全部数据

2、实现两个派生类 （1）数组排序 （2）数组反转

如果子类方法和父类方法功能相同，优先考虑覆写父类方法

class ArrayDemo{
    private int point = 0;
    private int[] data = null;

    public ArrayDemo(int length){
        // 传入的长度如果小于1则等于1
        if(length
关注
打赏
1688896170
查看更多评论

彭世瑜

暂无认证

  • 2浏览

    0关注

    2727博文

    0收益

  • 0浏览

    0点赞

    0打赏

    0留言

私信
关注
热门博文

[ 申请 ]友情链接：

快连vpn 快连 快连vpn 搜外友链 笔趣阁 爱思助手 ClashX教程 绘画宝宝 配音宝宝
0.0588s