Java中继承与多态及封装（第一篇）

Posted 2021-05-20 nuist__NJUPT

Java中继承与多态及封装

/**

• Java是面向对象的语言。具有面向对象的所有特征，包括继承性，封装性，多态性
• 继承的思想是从已有的类派生出新类，不同的类型可能会有 共同的特征和行为
• 可以将共同的特征和行为放到同一个类中，使他们可以被其它的类共享
• Java语言是单继承，一个类不能直接继承多个类，但是可以间接继承多个类
• 比如： Class A extends B , Class C extends A
• 则C直接继承A，间接继承B，C是 A的直接子类，C是B的间接子类
  */

/**
 * Java是面向对象的语言。具有面向对象的所有特征，包括继承性，封装性，多态性
 * 继承的思想是从已有的类派生出新类，不同的类型可能会有 共同的特征和行为
 * 可以将共同的特征和行为放到同一个类中，使他们可以被其它的类共享
 * Java语言是单继承，一个类不能直接继承多个类，但是可以间接继承多个类
 * 比如： Class A extends B , Class C extends A
 * 则C直接继承A，间接继承B，C是 A的直接子类，C是B的间接子类
 */
//定义一个父类Person类
public class Person {
    public String name ; //成员变量
    public int age ;
    public Person(){} //无参数构造方法
    public Person(String name, int age){ //带两个参数的构造方法
        this.name = name ;
        this.age = age ;
    }
    public void sayHello(){ //自定义的输出姓名方法
        System.out.println("我的名字是：" + name) ;
    }
}

• 有了Person类，定义Employee类就可以基继承Person类
• 下面定义Person类的子类Employee类
• 子类继承父类中非private的成员变量和成员方法
• 定义的类若缺少extends关键字，则所定义的类为object的直接子类
• Java仅支持单继承，即一个类最多有一个直接父类，Java中可以通过接口实现其它语言中的多重继承
• 注意：父类中定义的private成员变量和方法不能被子类继承，因此在子类中不能直接使用， 如果子类中定义了公共的访问方法和修改方法，子类可以通过这些方法来访问和修改它们

/**

/**
 * 有了Person类，定义Employee类就可以基继承Person类
 * 下面定义Person类的子类Employee类
 * 子类继承父类中非private的成员变量和成员方法
 * 定义的类若缺少extends关键字，则所定义的类为object的直接子类
 * Java仅支持单继承，即一个类最多有一个直接父类，Java中可以通过接口实现其它语言中的多重继承
 */
public class Employee extends Person{
    public double salary ; //员工薪水
    public Employee(){}
    public Employee(double salary){ //带一个参数的构造方法
        this.salary = salary ;
    }
    public Employee(String name, int age, double salary){
        super(name,age)  ; //等价于this.name = name , this.age = age
        this.salary = salary ;
    }
    public double computerSalary(int hours, double rate){
        //计算工资的方法
        double salary = rate * hours ;
        return this.salary + salary ;
    }
    public static void main(String[] args){
        Employee emp = new Employee("王国栋",24,5000) ;
        System.out.println("姓名：" + emp.name) ;
        System.out.println("年龄：" + emp.age) ;
        emp.sayHello() ;
        System.out.println(emp.computerSalary(10,50.0)) ;
    }
}

• 方法的覆盖，也叫做方法的重写，在子类中定义与父类中名字，参数列表，返回值类型都相同的方法，仅实现不同
• 方法的覆盖可以理解为同一个方法的不同实现
• 方法的重载：在一个类中定义多个名称相同但是参数不同的方法

/**
 * 方法的覆盖，也叫做方法的重写，在子类中定义与父类中名字，参数列表，返回值类型都相同的方法，仅实现不同
 * 方法的覆盖可以理解为同一个方法的不同实现
 * 方法的重载：在一个类中定义多个名称相同但是参数不同的方法
 */
 class Parent { //父类
    public void display(double i){
        System.out.println(i) ;
    }
}
public class Children extends Parent{
    @Override //覆盖方法的关键字
    public void display(double i){//方法的覆盖
        System.out.println(2 * i) ;
    }
    public void display(double i, int j){ //方法的重载
        System.out.println(i +" " + j) ;
    }
    public static void main(String[] args){
        Children children = new Children() ;
        children.display(10) ;
        children.display(10.0) ;
        children.display(10.0,20) ;
    }
}

• super关键字的使用
• 在子类中可以使用super关键字，用来引用当前对象的父类对象，它可用于下面三种情况
• 1.在子类中调用父类被覆盖的方法
• 2.在子类中调用父类的构造方法
• 3.在子类中调用父类被隐藏的成员变量
• this关键字的作用
• 1.解决局部变量与成员变量同名的问题
• 2.解决方法参数与成员变量同名的问题
• 3.用来调用该类的另一个构造方法

/**
 * super关键字的使用
 * 在子类中可以使用super关键字，用来引用当前对象的父类对象，它可用于下面三种情况
 * 1.在子类中调用父类被覆盖的方法
 * 2.在子类中调用父类的构造方法
 * 3.在子类中调用父类被隐藏的成员变量
 * this关键字的作用
 * 1.解决局部变量与成员变量同名的问题
 * 2.解决方法参数与成员变量同名的问题
 * 3.用来调用该类的另一个构造方法
 */
class Super{
    int x, y ;
    public Super(){
        System.out.println("创建父类对象") ;
        setXY(5,5) ;
    }
    public void setXY(int x, int y) { //修改x,y值的方法
        this.x = x ;
        this.y = y ;
    }
    public void display(){
        System.out.println("x = " + x  + " " + "y = " + y);
    }
}
class Sub extends Super{
    int x, z ;
    public Sub(){
        this(10,10) ; //调用本类中带两个参数的构造方法
        System.out.println("创建子类对象") ;
    }
    public Sub(int x, int z){
        super() ; //2.在子类中调用父类无参数的构造方法
        this.x = x ;
        this.z = z ;
    }
    @Override
    public void display(){ //覆盖了父类Super的display()方法
        super.display() ; //1.访问父类的display()方法
        System.out.println("x = " + x + " " + "y = " + y) ;
        System.out.println("super.x = " + super.x + ",super.y = " + super.y) ;//3.访问父类被覆盖的成员变量
    }
}
public class SuperTest {
    public static void main(String[] args){
        Sub sub = new Sub() ;
        sub.display() ;
    }
}

• 子类不能继承父类的构造方法，要创建子类对象需要使用默认构造方法或为子类定义构造方法
• Java语言规定，在创建子类对象时，必须先创建该类的所有父类对象，因此，在编写子类的构造方法时，
• 必须保证它能够调用父类的构造方法
• 1.使用super关键字调用父类的构造方法：不能使用super关键字调用间接父类的构造方法，super.super()是不合法
• 2.调用父类的默认构造方法
• 注意：在子类的构造方法中，若没有使用super关键字调用父类的构造方法，
• 则编译器将在子类的构造方法第一句加上super(),即调用父类无参数的构造方法
• 在子类构造方法中也可以使用this调用本类的其它构造方法
• this和super必须是构造方法的第一句，且仅能有其一
• 创建一个类的实例时，将会沿着继承链调用所有父类的构造方法，这叫做构造方法链

/**
 * 子类不能继承父类的构造方法，要创建子类对象需要使用默认构造方法或为子类定义构造方法
 * Java语言规定，在创建子类对象时，必须先创建该类的所有父类对象，因此，在编写子类的构造方法时，
 * 必须保证它能够调用父类的构造方法
 * 1.使用super关键字调用父类的构造方法：不能使用super关键字调用间接父类的构造方法，super.super()是不合法
 * 2.调用父类的默认构造方法
 * 注意：在子类的构造方法中，若没有使用super关键字调用父类的构造方法，
 * 则编译器将在子类的构造方法第一句加上super(),即调用父类无参数的构造方法
 * 在子类构造方法中也可以使用this调用本类的其它构造方法
 * this和super必须是构造方法的第一句，且仅能有其一
 * 创建一个类的实例时，将会沿着继承链调用所有父类的构造方法，这叫做构造方法链
 */
//定义交通工具类
class Vehicle{
    public Vehicle(){
        System.out.println("创建Vehicle对象") ;
    }
}
class Bicycle extends Vehicle{ //继承了Vehicle类
    private String brand ;
    public Bicycle(){
        this("保时捷911") ; //调用本类中带参数的构造方法
        System.out.println("创建Bicycle对象") ;
    }
    public Bicycle(String brand){
        this.brand = brand ;
    }

    public String getBrand(){
        return brand ;
    }
}
public class ElectricBicycle extends Bicycle{ //继承Bicycle类
    String factory ;
    public ElectricBicycle(){
        System.out.println("创建ElectricBicycle对象") ;
    }
    public static void main(String[] args){
      ElectricBicycle myBicycle = new ElectricBicycle() ;
      System.out.println(myBicycle.getBrand()) ;
    }
}

• 封装性与访问修饰符
• 封装性是面向对象的一个重要特征，在Java语言中，对象就是一组变量和方法的封装体
• 通过对象的封装，用户不必了解对象是如何实现的
• 只需要 通过对象提供的接口与对象进行交互就可以了
• 封装性实现了模块化和信息隐藏，有利于程序的移植性和对象的管理
• 对象的封装是通过下面两种方式实现的
• 1.通过包实现封装，在定义时，使用package语句指定类属于 哪一个包，包是Java语言封装的最大单位,定义了程序对类的访问权限
• 2.通过类或者类的成员访问权限实现封装性
• 类成员的访问权限
• 1.private访问修饰符：私有成员，只能被这个类本身访问
• 2.缺省访问修饰符：可被类本身和同一个包中的类所访问
• 3.protected访问修饰符：可以被不同包的子类访问
• 4.public访问修饰符：可以被任何类访问