荐 java学习(一)多态

希望各位新手程序员可以通过我这个博客学会多态。(尽量短一点)

多态体现形式：父类的引用指向自己的子类对象。 (简单理解：父类的方法被子类同名方法覆盖)
多态的前提：类之间必须有关系，要么基础，要么实现，存在覆盖。
多态的好处：提高程序的扩展性。
多态的弊端：只能使用父类中的成员。

打个比方，动物有小猪，小猫，小猪，小猫都是动物。
我们可以:

小猫 xx=new 小猫()；
小猪 xx=new 小猪()；
和下面的
动物 xx=new 小猪()；
动物 xx=new 小猫()；
是一个效果。
动物可以作为小猪，也可以作为小猫，这就是多态。

气死我了，上代码：

package duotai;

abstract class Animal{
	public abstract void eat();
}
class Cat extends Animal{
	public void eat() {
		System.out.print("小猫吃东西");
	}
}
class Pig extends Animal{
	public void eat() {
		System.out.print("小猪吃东西");
	}
}
public class duotai {
	public static void main(String[] args) {
		Cat cat=new Cat();
		Pig pig=new Pig();
		cat.eat();
		pig.eat();
	}
}
输出是：小猫吃东西小猪吃东西

下面写一个同样结果的程序:

package duotai;

abstract class Animal{
	public abstract void eat();
}
class Cat extends Animal{
	public void eat() {
		System.out.print("小猫吃东西");
	}
}
class Pig extends Animal{
	public void eat() {
		System.out.print("小猪吃东西");
	}
}

public class duotai {
 
	public static void eat(Animal a) {
		a.eat();
	}
	public static void main(String[] args) {
		Animal cat=new Cat();
		Animal pig=new Pig();//这叫向上转型，子类向父类转。
		eat(cat);
		eat(pig);
	}
}
这个输出是:小猫吃东西小猪吃东西

但是猪喜欢睡觉动物不是都喜欢睡觉，那小猪想表达睡觉怎么办？
气死我了，上代码。

package duotai;

abstract class Animal{
	public abstract void eat();
}
class Cat extends Animal{
	public void eat() {
		System.out.print("小猫吃东西");
	}
}
class Pig extends Animal{
	public void eat() {
		System.out.print("小猪吃东西");
	}
	public void sleep()
	{
		System.out.print("小猪在睡觉");
	}
}
public class duotai {
	public static void main(String[] args) {
		Animal pig=new Pig();
		pig.sleep();
	}
}
这个代码会报错的。因为Animal建立的Pig对象没有sleep函数/

气死我了上解决方法：

package duotai;

abstract class Animal{
	public abstract void eat();
}
class Cat extends Animal{
	public void eat() {
		System.out.print("小猫吃东西");
	}
}
class Pig extends Animal{
	public void eat() {
		System.out.print("小猪吃东西");
	}
	public void sleep()
	{
		System.out.print("小猪在睡觉");
	}
}

public class duotai {
 

	public static void main(String[] args) {
		Animal pig=new Pig();
		Pig a=(Pig)pig;//向下转型
		a.sleep();
	}

}
这样就好了。输出小猪在睡觉。

父类指向子类的时候，父类方法会被字类覆盖。(这是非静态方法哦，静态成员会被重写在另一个内存里，我们这样继承的话，父类的方法不会被子类重写)

package duotai;
class dad {
public void a() {
	System.out.print("a_dad");
}
public void b() {
	System.out.print("b_dad");
}
}
class son extends dad {
public void a() {
	System.out.print("a_son");
}
public void b() {
	System.out.print("b_son");
}
}
public class duotai {
	public static void main(String[] args) {
     dad k=new son();
     k.a();
     k.b();
	}
}
输出为a_son b_son
看代码的时候a

那么在类中存在的变量会不会和上面函数一样父类的方法被字类覆盖？
气死我了上代码：

package duotai;


class dad {
int num=1;
public void a() {
	System.out.print("a_dad");
}
public void b() {

	System.out.print("b_dad");
}
}
class son extends dad {
	int num=2;
public void a() {
	System.out.print("a_son");
}
public void b() {
	System.out.print("b_son");
}
}

public class duotai {
 

	public static void main(String[] args) {
     dad k=new son();
     son m=new son();
     System.out.print(k.num);
     System.out.print(m.num);
	}

}
输出为12事实证明父类的变量不会被字类的变量覆盖

每天一个学废小技巧：instanceof 确定对象类型
代码：

package duotai;

abstract class Animal{
	public abstract void eat();
}
class Cat extends Animal{
	public void eat() {
		System.out.print("小猫吃东西");
	}
}
class Pig extends Animal{
	public void eat() {
		System.out.print("小猪吃东西");
	}
	public void sleep()
	{
		System.out.print("小猪在睡觉");
	}
}

public class duotai {
 
	public static void dd(Animal a) {
		if(a instanceof Cat) {
			System.out.print("这是猫");
		}
		if(a instanceof Pig) {
			System.out.print("这是猪");
		}
	}
	public static void main(String[] args) {
		Animal cat=new Cat();
		Animal pig=new Pig();
		dd(cat);
		dd(pig);
	}
}

课后练习：

可以把人分男人和女人，人作为父类，男人女人继承人这个父类，具体功能各位可以随意写，建议初学者直接输出(System.out.print())自己用上转型，下转型完成一些操作。加油！！！

本文地址：https://blog.csdn.net/weixin_45743162/article/details/107161745