java基础之面向对象(三)

面向对象比较经典的例子，轻松理解多态的奥秘。

 大体思路：例：如果有题目要求你写一个富人养了狗、猫，它们都会叫（Syso)，并且有各自的名字，没学多态前，是不是得创建富人，狗、猫的类，然后分别写他们的叫，名字，学了多态后，你可以抽取成一个动物类，这个类中有这些动物都有的属性（名字）和抽象方法（叫），子类就是狗，猫，老虎类，继承动物类，然后重写其动物类（父类）的方法，并在构造函数中设置名字，就ok了，不用在狗猫，老虎类分别再写方法，见示例：

   类名：

Pet.java

 Dog.java

Snake.java

RichMan.java

Test.java

 

Pet.java

package RaisePet;

public abstract class Pet {//有抽象方法的类一定是抽象类 抽象类不能用来创建对象  抽象类为开发人员制定了相应的约束
	private String name;

	public String getName() {//子类中实现动物的名字
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public abstract void enjoy();  //抽象方法存在就是为了被子类覆盖（重写） 
}

Dog.java

package RaisePet;

public class Dog extends Pet {
	public Dog(String name) {
		super();
		this.setName(name);
	}

	public void enjoy() { //重写父类（Pet）的方法
		System.out.println(this.getName() + ":汪汪汪");

	}

}

Snake.java

package RaisePet;

public class Snake extends Pet {
	public Snake(String name) {
		this.setName(name);
	}

	public void enjoy() {
		System.out.println(this.getName() + ":嗖嗖嗖嗖");
	}


}

RichMan.java

package RaisePet;

public class RichMan {
	private String name;
	private Pet pet;

	public RichMan(String name, Pet pet) { // 富人的名字和传具体的动物对象叫什么（不清楚的看上篇文章向上转型），
		this.setPet(pet);
		this.setName(name);

	}

	public void play() {
		System.out.println(this.getName() + "正在和" + pet.getName() + "玩");
		pet.enjoy();

	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Pet getPet() {
		return pet;
	}

	public void setPet(Pet pet) {
		this.pet = pet;
	}

}

test.java

package RaisePet;

public class test {
	public static void main(String[] args){
	Dog d=new Dog("旺财");
	Snake s=new Snake("眼镜蛇");
	RichMan man=new RichMan("老王",s);
	man.play();
		
	}
}

输出：

下面看看接口和多态的小例子，首先get一下接口。

接口：和类的声明相似 ，interface 接口名字{ 接口体}，接口允许多实现，接口之间可以多继承

接口体：只有常量和抽象方法

而且常量的访问权限是public ,并且是 static 常量，抽象方法的访问权限是public 

一个类如果实现了某个接口，必须重写其所有方法，如果是抽象类实现接口，可以允许不重写所有方法。并且访问权限一定是public .说了这嘛多，看示例：

接口

interface A {
void say();


int a = 10;


}

实现接口：

class B implements A {


@Override
public void say() {
System.out.println("I am a gentleman." + a);


}


}

调用：

package RaisePet;


public class test {
public static void main(String[] args) {
B b = new B();
b.say();


}
}

打印：

现在看一个接口和多态的例子：

接口一：

package RaisePet;

public interface EXAM {
	abstract void test();

}

接口二：

package RaisePet;

public interface Protectable {//接口中所有的方法都是抽象方法 只存在常量 不存在属性 所有方法和常量都是public 
	public abstract void procted();

}

接口三：（多继承）

package RaisePet;

public interface Walk extends Protectable, EXAM {
	public abstract void walk();

}

多实现：

package RaisePet;

public class GoldMonkey implements Walk {// 接口用于多实现
	public void procted() {
		System.out.println("protect");
	}

	public void walk() {
		System.out.println("Walk");
	}

	@Override
	public void test() {
		System.out.println("EXAM");

	}
}

应用：

package RaisePet;

public class test02 {
public static void main(String[] args){
/**调用重写后的方法 */
Protectable g=new GoldMonkey();
g.procted();//父类引用指向子类对象 只有 procted方法

Walk w=(Walk)g;//继承了Protectable，向下转型
w.walk();
    w.procted();

GoldMonkey x=(GoldMonkey)g;//GoldMonkey=(GoldMonkey)w; 多实现 并且向下转型
x.procted();
x.walk();
}
}

打印：

接口和抽象类的比较：

都可以声明抽象方法，

接口只能声明常量，只能有抽象方法

抽象类可以有变量，可以有普通方法。