比如买票行为,学生和普通人都属于人,但是学生买票可以半价,而普通人是全票
class Animal{
String name;
int age;
public Animal(String name, int age){
this.name = name;
this.age = age;
}
public void eating(){
System.out.println(name + "吃饭");
}
}
class Dog extends Animal{
public Dog(String name, int age){
super(name, age);
}
@Override //重写父类
public void eating(){
System.out.println(name + "吃鱼");
}
}
class Cat extends Animal{
public Cat(String name, int age){
super(name, age);
}
@Override//重写父类
public void eating(){
System.out.println(name + "啃骨头");
}
}
class Animal{
String name;
int age;
public Animal(String name, int age){
this.name = name;
this.age = age;
}
public void eating(){
System.out.println(name + "吃饭");
}
}
class Dog extends Animal{
public Dog(String name, int age){
super(name, age);
}
@Override //重写父类
public void eating(){
System.out.println(name + "啃骨头");
}
}
class Cat extends Animal{
public Cat(String name, int age){
super(name, age);
}
@Override//重写父类
public void eating(){
System.out.println(name + "吃小鱼");
}
}
public class TestDemo {
public static void main(String[] args) {
Animal animal = new Dog("旺财", 3);//向上转型
}
}
class Animal{
String name;
int age;
public Animal(String name, int age){
this.name = name;
this.age = age;
}
public void eating(){
System.out.println(name + "吃饭");
}
}
class Dog extends Animal{
public Dog(String name, int age){
super(name, age);
}
@Override //重写父类
public void eating(){
System.out.println(name + "啃骨头");
}
}
class Cat extends Animal{
public Cat(String name, int age){
super(name, age);
}
@Override//重写父类
public void eating(){
System.out.println(name + "吃小鱼");
}
}
public class TestDemo {
//形参为父类引用,可以接受任意子类对象
public static void eatFood(Animal animal){
animal.eating();
}
public static void main(String[] args) {
Cat cat = new Cat("喵喵", 3);
eatFood(cat);
}
}
class Animal{
String name;
int age;
public Animal(String name, int age){
this.name = name;
this.age = age;
}
public void eating(){
System.out.println(name + "吃饭");
}
}
class Dog extends Animal{
public Dog(String name, int age){
super(name, age);
}
@Override //重写父类
public void eating(){
System.out.println(name + "啃骨头");
}
}
class Cat extends Animal{
public Cat(String name, int age){
super(name, age);
}
@Override//重写父类
public void eating(){
System.out.println(name + "吃小鱼");
}
}
public class TestDemo {
//方法返回值为父类引用,此时可以返回任意子类对象
public static Animal buyAnAnimal(String animal_name){
if(animal_name.equals("狗")) {
return new Dog("旺财", 2);
}
else if(animal_name.equals("猫")) {
return new Cat("喵喵", 3);
}
else{
return null;
}
}
public static void main(String[] args) {
System.out.println("进入宠物店:请问你需要什么动物");
Scanner sc = new Scanner(System.in);
String animal_name = sc.nextLine();
Animal animal = buyAnAnimal(animal_name);
System.out.println("你得到了:" + animal.name);
sc.close();
}
}
如下是向上转型, Animal animal = new Dog("旺财", 2) ,所以 animal 是无法调用 Dog 的特有方法 dog_method() 的
class Animal{
String name;
int age;
public Animal(String name, int age){
this.name = name;
this.age = age;
}
public void eating(){
System.out.println(name + "吃饭");
}
}
class Dog extends Animal{
public Dog(String name, int age){
super(name, age);
}
@Override //重写父类
public void eating(){
System.out.println(name + "啃骨头");
}
public void dog_method(){
System.out.println(name + "的特有方法");
}
}
class Cat extends Animal{
public Cat(String name, int age){
super(name, age);
}
@Override//重写父类
public void eating(){
System.out.println(name + "吃小鱼");
}
}
public class TestDemo {
public static void function(Animal animal){
animal.eating();
}
public static void main(String[] args) {
Animal animal = new Dog("旺财", 2);
animal.dog_mehtod();
}
}
但是我们可以向下转型,也即 让一个子类的引用指向强转后的父类对象 ,此时便可以调用 Dog 的特有方法 dog_method() 了
public class TestDemo {
public static void function(Animal animal){
animal.eating();
}
public static void main(String[] args) {
Animal animal = new Dog("旺财", 2);
Dog dog = (Dog)animal;//向下转型
dog.dog_method();
}
}
向下转型很不安全,而且有时会有严重的歧义。 Java中为 了提高向下转型的安全性,引入了 instanceof ,如果该表达式为 true ,则可以安全转换
讲到这里,其实已经完成了多态,所以日后我们就可以利用继承和转型来完成 传哪个对象就调用哪个对象的方法的目的
class Animal{
String name;
int age;
public Animal(String name, int age){
this.name = name;
this.age = age;
}
public void eating(){
System.out.println(name + "吃饭");
}
}
class Dog extends Animal{
public Dog(String name, int age){
super(name, age);
}
@Override //重写父类
public void eating(){
System.out.println(name + "啃骨头");
}
}
class Cat extends Animal{
public Cat(String name, int age){
super(name, age);
}
@Override//重写父类
public void eating(){
System.out.println(name + "吃小鱼");
}
}
public class TestDemo {
public static void function(Animal animal){
animal.eating();
}
public static void main(String[] args) {
Dog dog = new Dog("旺财", 2);
Cat cat = new Cat("喵喵", 3);
function(dog);
function(cat);
}
}
下面的代码中,B继承自A, func 方法被重写。在构造B对象时会调用A的构造方法,在A的构造方法中调用了 func 方法,但此时是B对象,所以会调用到B的 func ,而B对象而没有完成构造,所以 num 处于未被初始化状态,为0
class A{
public A(){
func();
}
public void func(){
System.out.println("A的func()方法");
}
}
class B extends A{
private int num = 1;
@Override
public void func(){
System.out.println("B的func()方法,num="+num);
}
}
public class TestDemo{
public static void main(String[] args) {
B b = new B();
b.func();
}
}
如下一个类 Shape ,其中有一个方法 draw ,作用是向屏幕打印某个具体的图形(没有具体实现),图形有很多种,这里给出了 Rectangle 、 Triangle 和 Circle 三个类,分别用于描述矩形、三角形和圆形,它们各自内部也有一个方法 draw ,重写了父类的方法,形成多态
class Shape{
public void draw(){
System.out.println("画一个图形");
}
}
class Rectangle extends Shape{
@Override
public void draw(){
System.out.println("画一个矩形");
}
}
class Triangle extends Shape{
@Override
public void draw(){
System.out.println("画一个三角形");
}
}
class Circle extends Shape{
@Override
public void draw(){
System.out.println("画一个三角形");
}
}
public class TestDemo {
public static void drawing(Shape input){
input.draw();
}
public static void main(String[] args) {
Circle circle = new Circle();
drawing(circle);
}
}
对于父类的方法,它的实现是没有意义的, 因为“画一个图形”这样的话太过抽象 ,无法具体去描述。 所以,我们可以不用实现它,将其改造为抽象方法,需要在方法返回值前加入关键字 abstract ,当某个类拥有抽象方法后它就变成了抽象类,也需要在其前面加入关键字 abstract 进行修饰
abstract class Shape{
abstract public void draw();//抽象方法
}
class Rectangle extends Shape{
@Override
public void draw(){
System.out.println("画一个矩形");
}
}
class Triangle extends Shape{
@Override
public void draw(){
System.out.println("画一个三角形");
}
}
class Circle extends Shape{
@Override
public void draw(){
System.out.println("画一个三角形");
}
}
public class TestDemo {
public static void drawing(Shape input){
input.draw();
}
public static void main(String[] args) {
Circle circle = new Circle();
drawing(circle);
}
}
⑤:抽象方法 不能被 final 和 static 修饰
留言与评论(共有 0 条评论) “” |