面向对象高级知识(一)

继承性
覆写
继承案例
- 基础实现
final 关键字
- 无法修改 final 修饰的常量
多态性

继承性

定义两个描述人与学生的类

Person.java

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

Student.java

class Student {
    private String name;
    private int age;
    private String school;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setSchool(String school) {
        this.school = school;
    }
    public String getSchool() {
        return this.school;
    }
    public String getName() {
        return this.name;
    }
    public int getAge() {
        return this.age;
    }
}

继承的基本实现

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;
    }
}
class Student extends Person { // Student类继承了Person类
    // 此类没有定义任何的操作方法
}
public class TestDemo {
    public static void main(String args[]) {
        Student stu = new Student(); // 实例化的是子类
        stu.setName("张三"); // Person类定义
        stu.setAge(20); // Person类定义
        System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge());
    }
}

/*
姓名：张三，年龄：20
*/

在子类中扩充方法

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;
    }
}
class Student extends Person { // Student类继承了Person类
    private String school ; // 子类扩充的属性
    public void setSchool(String school) { // 扩充的方法
        this.school = school ;
    }
    public String getSchool() { // 扩充的方法
        return this.school ;
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Student stu = new Student(); // 实例化的是子类
        stu.setName("张三"); // Person类定义
        stu.setAge(20); // Person类定义
        stu.setSchool("中北大学") ; // Student类扩充方法
        System.out.println("姓名：" + stu.getName() + "，年龄：" + stu.getAge()
                + "，学校：" + stu.getSchool());
    }
}

/*
姓名：张三，年龄：20，学校：中北大学
*/

错误的继承

Java 当中只能单继承，不能继承多个父类

class A {}
class B {}
class C extends A,B {} // 一个子类继承了两个父类

多层继承

Java 当中虽然不能多继承，但是可以多层继承

class A {}
class B extends A {} // B类继承A类
class C extends B {} // C类继承B类

覆写

没有实现方法覆写

class A {
    public void fun() { // 在父类中定义的方法
        System.out.println("A类中的fun()方法。") ;
    }
}
class B extends A { // 定义子类，此时没有覆写任何方法
}
public class TestDemo {
    public static void main(String args[]) {
        B b = new B() ; // 实例化子类对象
        b.fun() ; // 调用fun()方法
    }
}

/*
A类中的fun()方法。
*/

实现方法覆写

class A {
    public void fun() { // 在父类中定义的方法
        System.out.println("A类中的fun()方法。") ;
    }
}
class B extends A { // 定义子类，此时没有覆写任何方法
    public void fun() { // 此处为覆写
        System.out.println("B类中的fun()方法。") ;
    }
}
public class TestDemo {
    public static void main(String args[]) {
        B b = new B() ; // 实例化子类对象
        b.fun() ; // 调用fun()方法，此时方法被覆写，所以调用被覆写过的方法
    }
}

/*
B类中的fun()方法。
*/

正确的覆写

class A {
    public void fun() { // 在父类中定义的方法
        System.out.println("A类中的fun()方法。") ;
    }
}
class B extends A { // 定义子类，此时没有覆写任何方法
    // 父类中的fun()方法权限为public，此时子类中的方法权限并没有变得严格，而是与父类一致
    public void fun() { // 此处为覆写
        System.out.println("B类中的fun()方法") ;
    }
}
public class TestDemo {
    public static void main(String args[]) {
        B b = new B() ; // 实例化子类对象
        b.fun() ; // 调用fun()方法，此时方法被覆写，所以调用被覆写过的方法
    }
}

/*
B类中的fun()方法
*/

正确的方法覆写

class A {
    void fun() { // 在父类中定义的方法
        System.out.println("A类中的fun()方法。") ;
    }
}
class B extends A { // 定义子类，此时没有覆写任何方法
    // 父类中的fun()方法权限为public，此时子类中的方法权限与父类相比更加宽松
    public void fun() { // 此处为覆写
        System.out.println("B类中的fun()方法。") ;
    }
}

使用private声明父类中的方法

class A {
    public void fun() {
        this.print() ; // 调用print()方法
    }
    private void print() { // 此为private权限，无法覆写
        System.out.println("中北大学安卓实验室") ;
    }
}
class B extends A {
    public void print() { // 不能覆写print()方法
        System.out.println("更多课程请访问：www.yootk.com") ;
    }
}
public class TestDemo {
    public static void main(String args[]) {
        B b = new B() ; // 实例化子类对象
        b.fun() ; // 调用父类继承来的fun()方法
    }
}

/*
中北大学安卓实验室
*/

利用super方法访问父类中方法

class A {
    public void print() {
        System.out.println("中北大学安卓实验室") ;
    }
}
class B extends A {
    public void print() { // 覆写的是print()方法
        super.print(); // 访问父类中的print()方法
        System.out.println("中北大学安卓创新实验室") ;
    }
}
public class TestDemo {
    public static void main(String args[]) {
        B b = new B() ; // 实例化子类对象
        b.print() ;
    }
}

/*
中北大学安卓实验室
中北大学安卓创新实验室
*/

继承案例

基础实现

class Array { // 定义数组操作类
    private int data[]; // 定义一个数组对象，此数组由外部设置长度
    private int foot; // 表示数组的操作脚标
    /**
     * 构造本类对象时需要设置大小，如果设置的长度小于0则维持一个大小
     * @param len 数组开辟时的长度
     */
    public Array(int len) {
        if (len > 0) { // 设置的长度大于0
            this.data = new int[len]; // 开辟一个数组
        } else { // 设置的长度小于等于0
            this.data = new int[1]; // 维持一个元素的大小
        }
    }
    /**
     * 向数组中增加元素
     * @param num 要增加的数据
     * @return 如果数据增加成功返回true，如果数组中保存数据已满则返回false
     */
    public boolean add(int num) {
        if (this.foot < this.data.length) { // 有空间保存
            this.data[this.foot++] = num; // 保存数据，修改脚标
            return true; // 保存成功
        }
        return false; // 保存失败
    }
    /**
     * 取得所有的数组内容
     * @return 数组对象引用
     */
    public int[] getData() {
        return this.data;
    }
}
public class TestDemo {
    public static void main(String args[]) {
        Array arr = new Array(3); // 实例化数组操作类对象，可操作数组长度为3
        System.out.print(arr.add(20) + "、"); // 可以保存数据
        System.out.print(arr.add(10) + "、"); // 可以保存数据
        System.out.print(arr.add(30) + "、"); // 可以保存数据
        System.out.println(arr.add(100) + "、"); // 不可以保存数据，返回false
        int[] temp = arr.getData(); // 取得全部数组数据
        for (int x = 0; x < temp.length; x++) { // 循环输出数据
            System.out.print(temp[x] + "、");
        }
    }
}

/*
true、true、true、false、
20、10、30、
*/

final关键字

观察final定义的类

class A {
    public final void fun() {} // 此方法不允许子类覆写
}
class B extends A {
    public void fun() {} // 错误：此处不允许覆写
}

无法修改final修饰的常量

class A {
    final double GOOD = 100.0; // GOOD级别就是100.0
    public final void fun() {
        GOOD = 1.1; // 错误：不能够修改常量
    }
}

多态性

观察以下程序

class A {
public void print() {
        System.out.println("A、public void print(){}");
    }
}
class B extends A {
    public void print() { // 此时子类覆写了父类中的print()方法
        System.out.println("B、public void print(){}");
    }
}
public class TestDemo {
    public static void main(String args[]) {
        B b = new B(); // 实例化的是子类对象
        b.print(); // 调用被子类覆写过的方法
    }
}

/*
B、public void print(){}
*/

对象向上转型

public class TestDemo {
    public static void main(String args[]) {
        A a = new B(); // 实例化的是子类对象，对象向上转型
        a.print(); // 调用被子类覆写过的方法
    }
}
/*
B、public void print(){}
*/

对象向下转型

public class TestDemo {
    public static void main(String args[]) {
        A a = new B(); // 实例化的是子类对象，对象向上转型
        B b = (B) a ; // 对象需要强制性地向下转型
        b.print(); // 调用被子类覆写过的方法
    }
}
/*
B、public void print(){}
*/

错误的向下转型操作

public class TestDemo {
    public static void main(String args[]) {
        A a = new A(); // 直接实例化子类对象
        // 此时并没有发生子类对象向上转型的操作，所以强制转型会带来安全隐患
        B b = (B) a; // 强制向下转型，此处产生“ClassCastException”异常
        b.print(); // 此语句无法执行
    }
}

子类扩充父类方法

class A {
    public void print() {
        System.out.println("A、public void print(){}");
    }
}
class B extends A { // 定义A的子类
    public void print() { // 此时子类覆写了父类中的print()方法
        System.out.println("B、public void print(){}");
    }
    /**
     * 在子类中扩充一个新的方法，但是此方法只能由子类对象调用，父类对象不能调用
     */
    public void funB() {
        System.out.println("B、扩充的funB()方法");
    }
}

向下转型用于调用子类中的特殊功能

class A {
    public void print() {
        System.out.println("A、public void print(){}");
    }
}
class B extends A { // 定义A的子类
    public void print() { // 此时子类覆写了父类中的print()方法
        System.out.println("B、public void print(){}");
    }
    /**
     * 在子类中扩充一个新的方法，但是此方法只能由子类对象调用，父类对象不能调用
     */
    public void funB() {
        System.out.println("B、扩充的funB()方法");
    }
}
public class TestDemo {
    public static void main(String args[]) {
        fun(new B()); // 向上转型，只能调用父类中定义的方法
    }
    public static void fun(A a) {
        B b = (B) a; // 要调用子类的特殊操作，需要向下转型
        b.funB(); // 调用子类的扩充方法
    }
}

/*
B、扩充的funB()方法
*/

使用instanceof判断

class A {
    public void print() {
        System.out.println("A、public void print(){}");
    }
}
class B extends A { // 定义A的子类
    public void print() { // 此时子类覆写了父类中的print()方法
        System.out.println("B、public void print(){}");
    }
    public void funB() {
        System.out.println("B、扩充的funB()方法");
    }
}
public class TestDemo {
    public static void main(String args[]) {
        fun(new B()) ; // 对象向上转型
    }
    public static void fun(A a) {
        a.print() ;
        if (a instanceof B) { // 如果a对象是B类的实例
            B b = (B) a; // 向下转型
            b.funB(); // 调用子类扩充的方法
        }
    }
}

/*
B、public void print(){}
B、扩充的funB()方法
*/

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

面向对象高级知识(一).md

面向对象高级知识(一).md

面向对象高级知识(一)

继承性

定义两个描述人与学生的类

继承的基本实现

在子类中扩充方法

错误的继承

多层继承

覆写

没有实现方法覆写

实现方法覆写

正确的覆写

正确的方法覆写

使用private声明父类中的方法

利用super方法访问父类中方法

继承案例

基础实现

final关键字

观察final定义的类

无法修改final修饰的常量

多态性

观察以下程序

对象向上转型

对象向下转型

错误的向下转型操作

子类扩充父类方法

向下转型用于调用子类中的特殊功能

使用instanceof判断

Files

面向对象高级知识(一).md

Latest commit

History

面向对象高级知识(一).md

File metadata and controls

面向对象高级知识(一)

继承性

定义两个描述人与学生的类

继承的基本实现

在子类中扩充方法

错误的继承

多层继承

覆写

没有实现方法覆写

实现方法覆写

正确的覆写

正确的方法覆写

使用private声明父类中的方法

利用super方法访问父类中方法

继承案例

基础实现

final关键字

观察final定义的类

无法修改final修饰的常量

多态性

观察以下程序

对象向上转型

对象向下转型

错误的向下转型操作

子类扩充父类方法

向下转型用于调用子类中的特殊功能

使用instanceof判断