亲宝软件园·资讯

展开

Java 继承和多态 Java面向对象编程之继承和多态以及包的解析与使用范例

Unstoppedable 人气:0
想了解Java面向对象编程之继承和多态以及包的解析与使用范例的相关内容吗,Unstoppedable在本文为您仔细讲解Java 继承和多态 的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:Java,继承,Java,多态,Java,包,下面大家一起来学习吧。

1.继承

为什么要有继承?
多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,
那么多个类无需再定义这些属性和行为,只要继承那个类即可。

此处的多个类称为子类(派生类),单独的这个类称为父类(基类 或超类)。可以理解为:“子类 is a 父类”

1.1继承的基本使用

类继承语法规则:

class 子类 extends 父类{ }

继承的作用:

注意:

如下代码示例:

class Animal { 
    public String name; 
    public Animal(String name) { 
    this.name = name; 
    } 
    public void eat(String food) { 
    System.out.println(this.name + "正在吃" + food); 
    } 
} 
class Cat extends Animal { 
    public Cat(String name) { 
    // 使用 super 调用父类的构造方法. 
    super(name); 
    } 
} 
class Bird extends Animal { 
    public Bird(String name) {
    super(name); 
    } 
    public void fly() { 
    System.out.println(this.name + "正在飞 ︿( ̄︶ ̄)︿"); 
    } 
} 
public class Test { 
    public static void main(String[] args) { 
    Cat cat = new Cat("小黑"); 
    cat.eat("猫粮"); 
    Bird bird = new Bird("圆圆"); 
    bird.fly(); 
    } 
}

1.2 protected 关键字

刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 “封装” 的初衷.
两全其美的办法就是 protected 关键字.

四种权限修饰符:

四种权限修饰

1.3 final 关键字

曾经我们学习过 final 关键字, 修饰一个变量或者字段的时候, 表示 常量 (不能修改).

final int a = 10; 
a = 20; // 编译出错

final 关键字也能修饰类, 此时表示被修饰的类就不能被继承

final public class Animal { 
 ... 
} 
public class Bird extends Animal { 
 ... 
} 
// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继承

final 关键字的功能是 限制 类被继承。我们平时使用的String字符串类,就是被final修饰的,不能被继承。

2.多态

2.1向上转型

在刚才的例子中, 我们写了形如下面的代码:

Bird bird = new Bird("圆圆"); 

这个代码也可以写成这个样子

Bird bird = new Bird("圆圆"); 
Animal bird2 = bird; 
// 或者写成下面的方式
Animal bird2 = new Bird("圆圆"); 

此时 bird2 是一个父类 (Animal) 的引用, 指向一个子类 (Bird) 的实例. 这种写法称为 向上转型.

向上转型是子类对象转成父类对象

向上转型发生的时机:

直接赋值的方式我们已经演示了. 另外两种方式和直接赋值没有本质区别

方法传参

代码示例:

public class Test { 
    public static void main(String[] args) { 
    Bird bird = new Bird("圆圆"); 
    feed(bird); 
    } 
    public static void feed(Animal animal) { 
    animal.eat("谷子"); 
    } 
} 
// 执行结果
圆圆正在吃谷子

此时形参 animal 的类型是 Animal (基类), 实际上对应到 Bird (父类) 的实例.

方法返回

代码示例

public class Test { 
   public static void main(String[] args) { 
   Animal animal = findMyAnimal(); 
   } 
   public static Animal findMyAnimal() { 
   Bird bird = new Bird("圆圆"); 
   return bird; 
   } 
}

此时方法 findMyAnimal 返回的是一个 Animal 类型的引用, 但是实际上对应到 Bird 的实例

2.2动态绑定

当子类和父类中出现同名方法的时候, 再去调用会出现什么情况呢?

对前面的代码稍加修改, 给 Bird 类也加上同名的 eat 方法, 并且在两个 eat 中分别加上不同的日志.

如下:

// Animal.java 
public class Animal { 
 protected String name; 
 public Animal(String name) { 
 this.name = name; 
 } 
 public void eat(String food) { 
 System.out.println("我是一只小动物"); 
 System.out.println(this.name + "正在吃" + food); 
 }
} 
// Bird.java 
public class Bird extends Animal { 
 public Bird(String name) { 
 super(name); 
 } 
 public void eat(String food) { 
 System.out.println("我是一只小鸟"); 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Test.java 
public class Test { 
 public static void main(String[] args) { 
 Animal animal1 = new Animal("圆圆"); 
 animal1.eat("谷子"); 
 Animal animal2 = new Bird("扁扁"); 
 animal2.eat("谷子"); 
 } 
} 

// 执行结果
我是一只小动物
圆圆正在吃谷子
我是一只小鸟
扁扁正在吃谷子

此时, 我们发现:

因此, 在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引
用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为 动态绑定

2.3方法重写

定义:在子类中可以根据需要对从父类中继承来的方法进行改造,也称
为方法的重置、覆盖。在程序执行时,子类的方法将覆盖父类的方法。

要求:

注意:
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写),或者同时声明为static的(不是重写)。因为static方法是属于类的,子类无法覆盖父类的方法

方法重写举例1:

public class Person {
    public String name;
    public int age;
    public String getInfo() {
    return "Name: "+ name + "\n" +"age: "+ age;
    } 
}
public class Student extends Person {
    public String school;
    public String getInfo() { //重写方法
    return "Name: "+ name + "\nage: "+ age 
    + "\nschool: "+ school;
}
public static void main(String args[]){
    Student s1=new Student();
    s1.name="Bob";
    s1.age=20;
    s1.school="school2";
    System.out.println(s1.getInfo()); //Name:Bob age:20 school:school2
    } 
}

方法重写举例2:

class Parent {
    public void method1() {}
}
class Child extends Parent {
    //非法,子类中的method1()的访问权限private比被覆盖方法的访问权限public小
    private void method1() {} 
}
public class UseBoth {
    public static void main(String[] args) {
    Parent p1 = new Parent();
    Child c1 = new Child();
    p1.method1();
    c1.method1();
    }
}

2.4向下转型

向下转型就是父类对象转成子类对象. 相比于向上转型来说, 向下转型没那么常见,
但是也有一定的用途.

对于 Animal animal = new Bird(“圆圆”) 这样的代码:

编译器检查有哪些方法存在, 看的是 Animal 这个类型

执行时究竟执行父类的方法还是子类的方法, 看的是 Bird 这个类型.

那么想实现刚才的效果, 就需要向下转型.

// (Bird) 表示强制类型转换
Bird bird = (Bird)animal; 
bird.fly(); 
// 执行结果
圆圆正在飞

为了让向下转型更安全, 我们可以先判定一下看看 animal 本质上是不是一个 Bird 实例, 再来转换

Animal animal = new Cat("小猫"); 
if (animal instanceof Bird) { 
 Bird bird = (Bird)animal; 
 bird.fly(); 
}

instanceof 可以判定一个引用是否是某个类的实例. 如果是,则返回 ture。 这时再进行向下转型就比较安全了。

2.5super 关键字

2.5.1 super 关键字的基本用法

在Java类中使用super来调用父类中的指定操作:

注意:

空间的标识

示例1使用了 super 来调用父类的构造器(这个代码前面已经写过了)

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

示例2使用 super 来调用父类的普通方法

public class Bird extends Animal { 
 public Bird(String name) { 
 super(name); 
 } 
 @Override 
 public void eat(String food) { 
 // 修改代码, 让子调用父类的接口. 
 super.eat(food); 
 System.out.println("我是一只小鸟"); 
 System.out.println(this.name + "正在吃" + food); 
 } 
}

2.5.2 this和super的区别

this 和 super 的区别

3.包的使用

包 (package) 是组织类的一种方式.
使用包的主要目的是保证类的唯一性.
例如, 你在代码中写了一个 Test 类. 然后你的同事也可能写一个 Test 类. 如果出现两个同名的类, 就会冲突, 导致代码不能编译通过

3.1导入包中的类

包 (package) 是组织类的一种方式.
使用包的主要目的是保证类的唯一性
代码示例:

public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }
}

可以使用 import 语句导入包

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }
}

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

注意:Java是用到包中的那个类就导入那个类

但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.
例如:

import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
        // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
        Date date = new Date();
        System.out.println(date.getTime());
   }
}
// 编译出错

在这种情况下我们就需要完整的包名

import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
        // 静态导入的方式写起来更方便一些.但不推荐
        // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
        double result = sqrt(pow(x, 2) + pow(y, 2));
        System.out.println(result);
   }
}

3.2常见系统包

加载全部内容

相关教程
猜你喜欢
用户评论