java面对对象编程-多态

介绍

方法的多态

多态是在继承，重载，重写的基础上实现的

我们可以看看这个代码

package b;

public class main_ {

	public static void main(String[] args) {
//		graduate gra=new graduate();
//		gra.cry();//这个时候，子类的cry方法就重写了父类的方法
		aa a=new aa();
		System.out.println(a.sun(1,2,3));
		System.out.println(a.sun(1,3));
		
	}
	
}
class father{//父类。
	private void say() {
		System.out.println("b say()方法被调用");
		
	}
	
	
}
class aa extends father_{//子类继承父类
	public int sun(int n1,int n2) {//和下面的sum构成方法重载
		return n1+n2;
		
	}
	public int sun(int n1,int n2,int n3) {//和下面的sum构成方法重载
		return n1+n2+n3;
		
	}
	
	
}

用方法的重载

方法的重写

我现在在子类和父类中都加上say方法，并创建对象调用，虽然都是say 方法，但调用的对象不同

package b;

public class main_ {

	public static void main(String[] args) {
//		graduate gra=new graduate();
//		gra.cry();//这个时候，子类的cry方法就重写了父类的方法
		aa a=new aa();
		System.out.println(a.sun(1,2,3));
		System.out.println(a.sun(1,3));
		father b=new father();
		b.say();
		a.say();
		
	}
	
}
class father{//父类。
	public void say() {
		System.out.println("b say()方法被调用");
		
	}
	
	
}
class aa extends father_{//子类继承父类
	public int sun(int n1,int n2) {//和下面的sum构成方法重载
		return n1+n2;
		
	}
	public int sun(int n1,int n2,int n3) {//和下面的sum构成方法重载
		return n1+n2+n3;
		
	}
	
	public void say() {
		System.out.println("a say()方法被调用");
		
	}
	
}

多态的具体表现。

我们先来看看编译类型和运行类型

1. 编译时类型：也被称为静态类型，是变量在声明时的类型或者可以理解为是引用的类型。编译时类型在编译期确定，并且在程序运行过程中不会发生改变。编译器在编译时就会检查对应的类型规则。

Animal animal = new Dog(); // 这里animal的编译时类型就是Animal

1. 运行时类型：也被称为动态类型，在程序运行过程中动态绑定的类型，即实际的对象类型。运行时类型可能会在运行期改变，具体的类型是在运行时确定的。、

Animal animal = new Dog(); // 这里animal的运行时类型就是Dog animal = new Cat(); // 这里animal的运行时类型变为Cat

在堆栈中的

在`Animal myDog = new Dog();`这句代码中，涉及到了两部分的内存分配：堆内存和栈内存，他们的用途和特性各不相同。 1. 堆内存（Heap）: 这是存放所有对象实例以及数组的地方。在Java中，通过`new`关键字创建的对象或数组都会在堆中分配内存。所以，`new Dog()`创建的新的Dog对象就存放在堆内存中。 2. 栈内存（Stack）：存放了基本类型的变量（int, double, float, boolean, char等）和对象引用变量。每个线程运行时都有自己的栈，栈中的数据只在当前线程中有效。所以，`myDog`是一个引用类型的变量，它存放在栈内存中。它持有的是堆内存中的`Dog`对象的引用（可以理解为指向堆内存中`Dog`对象的地址）。 因此，`Animal myDog = new Dog();`这句代码，一个`Dog`类型的对象实例被创建在堆内存中，`myDog`这个引用变量被创建在栈内存中，并且`myDog`持有了这个`Dog`实例的引用。这样，通过`myDog`, 我们就可以指向和操作这个`Dog`实例了。 这种处理方式的一个重要理解是，当`myDog`的作用域结束或者被设为null，只是栈内存中的引用消失了，但是堆内存中的`Dog`对象还在，除非没有其他的引用指向这个`Dog`对象，那它就会被认为是垃圾，等待垃圾回收器在恰当的时候删除它。

真正理解

在这段代码`Animal myDog = new Dog();`中，`Animal`是一个类，在Java中被用作数据类型。在这个上下文中，它标识了`myDog`引用变量应该引用的对象类型。它并不直接占据堆或栈中的空间，它存在于源代码以及编译后的字节码中。 具体的说，`Animal`是一个reference(引用)类型，而`myDog`是一个reference(引用)变量，它的类型就是`Animal`。`myDog`变量存储在栈内存里，而真正的对象实例`new Dog()`则存储在堆内存里。 `Animal`的存在，影响的是`myDog`这个引用变量可以指向堆内存中的哪些对象。准确地说，`myDog`可以指向堆内存中的`Animal`对象，也可以指向任何一个`Animal`子类的对象（如这里的`Dog`对象）。 因此，`Animal`并不直接占据内存，而是确定了`myDog`引用变量可以引用哪种类型的对象。同时，在编译期，它也决定了可以通过`myDog`变量调用哪些方法和访问哪些字段。

多态代码

public class Animal {
    public void sound(){
        System.out.println("动物发出声音");
    }
}

public class Dog extends Animal {
    public void sound(){
        System.out.println("汪汪汪");
    }
}

public class Cat extends Animal {
    public void sound(){
        System.out.println("喵喵喵");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        myDog.sound();
        myCat.sound();
    }
}

多态的动物

小提示

在java中 public void feed(Dog dog,Bone bone)其中的Dog dog,Bone bone是什么

在这个方法定义中:

- public void feed(Dog dog, Bone bone)

- feed是方法名

- public表示该方法可在任何位置访问

- void表示该方法没有返回值

- Dog dog, Bone bone 是该方法的参数(parameters)

- Dog表示参数的类型为Dog类

- dog是参数名,表示传入的实参对象会以dog这个名字在方法内访问

- Bone bone表示下一个参数的类型为Bone类,名称为bone

所以简单总结:

- Dog dog, Bone bone定义了这个feed方法需要两个参数
- 第一个参数是Dog类型,名称为dog
- 第二个参数是Bone类型,名称为bone
- 这两个参数在方法内通过dog和bone这个名字来访问传入的实参对象

所以这个方法定义表示,feed方法需要传入两个对象,一个是Dog类型,一个是Bone类型,然后在方法内部就可以通过dog和bone来操作这两个对象了。