多态

• Object类

Object类
        老祖宗，一切java类的根基类

• toString

  toString 
          如果打印对象，会默认调用toString方法，如果没有重写，调用的就是
 父类的（Object），如果重写了，调用的就是重写的

public class Test_toString {
	public static void main(String[] args) {
		Cat cat = new Cat();
		cat.run();
		cat.name = "张二狗";
		cat.type = "中华田园猫";
		cat.color = "杂毛";
		System.out.println(cat);// 对象的地址
	}
}

class Animal extends Object {
	// 种类
	String type;

	// 奔跑
	static void run() {
		System.out.println("run...");
	}
}

class Cat extends Animal {
	String color;
	String name;

	@Override
	public String toString() {
		return "Cat [color=" + color + ",name=" + name + ",type=" + type + "]";
	}

	static void run() { // static修饰的类不能被重写
		System.out.println("小猫奔跑....");
	}

}

 

• equals

 * equals（Object obj）        Boolean     -Object
 * 方法名    参数                返回值类型    所属类
 * 
 * equals  和  ==
 *         == 比较的是两个内容的地址
 *         equals 比较的是对象的内容(重写)
 * 
 * equals源码
 *         public boolean equals(Object obj){
 *             return (this==obj);
 *         }

public class Test_equals {
	public static void main(String[] args) {
		User user1 = new User("张三", 15);
		User user2 = new User("李四", 14);
		System.out.println(user1);
		System.out.println(user2);
		
		//比较年龄
		System.out.println(user1.equals(user2));
	}
}

class User {
	private String name;
	private int age;

	// 带参构造
	public User(String name, int age) {
		this.name = name;
		this.age = age;
	}

	// 设置器与访问器
	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + ", toString()="
				+ super.toString() + "]";
	}

	// 重写equals方法,比较用户的年龄是否相同
	@Override
	public boolean equals(Object obj) {
		// 先比较地址,如果两个对象的地址都相同,内容一定相同
		if (this == obj) {
			return true;
		}

		// 判断参数是否为User类型的对象
		if (obj instanceof User) {
			User u1 = (User) obj;
			int age1 = u1.age;
			int age2 = this.age;
			return age1 == age2;
		}
		return false;
	}
}

• 多态

 * 多态
 *     一种事物的多种表现形式|多种形态
 * 
 * 多态的最终体现:父类的引用指向子类的对象
 * 前提是:继承
 * 
 * 注意: 多态形式,使用父类的引用去调用方法时,调用的是子类中重写的方法
 * 
 *     实现条件:
 *         继承
 *         方法的重写
 *         父类的引用指向子类的对象
 * 
 * 多态是方法的多态,和属性无关
 *
 * 成员方法:
 *         编译期:看父类类型,如果父类中存在当前成员方法,就不会报错,如果不存在就报错
 *         运行期:运行看对象,先运行子类重写的方法,如果子类中没有,调用父类的方法
 *         编译看类型,运行找对象
 * 
 * 成员属性:
 *         编译期:看父类类型,如果父类中存在当前成员属性,就不会报错,如果不存在就报错
 *         运行期:看父类,如果父类中存在就是父类中属性的值,如果不存在,编译不通过
 *         编译运行看父类|左边
 * 
 * 做题四大原则：
 *     1、继承链，自己没有找父亲；
 *     2、编译看类型+确定方法表，运行找对象
 *     3、就近最优原则：自己没有找父亲
 *     4、发生多态，基类对子类的新增方法不可见

public class Test_polym1 {
	public static void main(String[] args) {
		Fu f = new Zi();
		System.out.println(f.a);// 5

		f.test();// Zi
		// f.self(); 不可调用
	}
}

class Fu {
	int a = 5;

	void test() {
		System.out.println("FU");
	}
}

class Zi extends Fu {
	int a = 10;

	@Override
	void test() {
		System.out.println("Zi");
	}

	// 新增
	void self() {
		System.out.println("我是子类新增方法");
	}
}

• 多态练习

 * 多态调用的时候,编译的时候确定自己的方法表,找自己最适合的
 * 没有择优而选,就近原则

public class Test_polym2 {
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new B();//多态
		B b = new B();
		C c = new C();
		D d = new D();
		
		System.out.println(a1.show(b));// A   A
		System.out.println(a1.show(c));// A   A 
		System.out.println(a1.show(d));// A   D
		
		// 父类show(D) show(A)
		// 子类show(B) show(A)
		System.out.println(a2.show(b));// B   A------注意
		System.out.println(a2.show(c));// B   A
		System.out.println(a2.show(d));// A   D
		System.out.println(b.show(b));//  B   B
		System.out.println(b.show(c));//  B   B 
		System.out.println(b.show(d));//  A   D
	}
}

class A {
	public String show(D obj) {
		return ("A and D");
	}

	public String show(A obj) {
		return ("A and A");
	}
}

class B extends A {
	public String show(B obj) {
		return ("B and B");
	}

	public String show(A obj) {
		return ("B and A");
	}
}

class C extends B {
}

class D extends B {
}

• 对象转型

 * java是一种强类型语言:定义了变量的类型就不会再变,除非强制转型
 * 
 * 对象转型:casting
 *     孔子装爹
 *         class 孔子他爹{int age=80;void teach(){做生意..}}
 *         class 孔子 extends 孔子爹{int age=60;void teach(){论语..}}
 *         有人来找孔子爹去授课,但是孔子爹出去旅行了,孔子代替他爹
 *         化妆  ---成孔子他爹的样子
 * 
 *         向上转型:upcasting
 *             父类类型  父类引用=new 子类类型();  ---公式
 * 
 * 
 *         卸妆 --变回自己的样子
 * 
 *         向下转型:downcasting
 *             子类类型  子类引用=(子类类型)父类引用;  ---公式
 * 
 * java.lang.ClassCastException 类型准换异常
 * 
 * 引用 instanceof 类型       运算符
 *     判断左边的引用是否为右边类型的引用或者是否为右边类型的子类的实例
 *     如果是,返回true;不是,返回false.
 *     编译看继承链

public class Test_casting {
	public static void main(String[] args) {
		// 多态
		Father fa = new Son();
		fa.teach();

		// 向下转型----类型判断
		if (fa instanceof Brother) {
			Brother b = (Brother) fa;
			System.out.println("Brother");
		}
		if (fa instanceof Son) {
			Son son = (Son) fa;
			son.play();
			System.out.println("Son");
		}
	}
}

class Father {
	void teach() {
		System.out.println("做生意...");
	}
}

class Son extends Father {
	void teach() {
		System.out.println("论语...");
	}

	// 新增方法
	void play() {
		System.out.println("吃鸡游戏...");
	}
}

// 兄弟类型
class Brother extends Father {

}

• 抽象类

 * 抽象的  abstract
 *         抽象类:说不清楚,解释不明白的类就是抽象类
 *         抽象方法:说不清楚的,解释不明白的方法就是抽象方法
 * 
 * 如何定义抽象类:被abstract修饰的类
 * 如何定义抽象方法:被abstract修饰的方法
 *             抽象方法没有方法体
 *             抽象方法只能存在于抽象类中
 * 
 * 
 * 两个抽象方法
 * 注意:
 *         1.抽象类不能实例化
 *         2.抽象方法一旦被重写后,就可以不用再次被重写了
 *         3.抽象方法一定要被重写的
 *         4.抽象方法只能存在于抽象类中,抽象类中可以存在普通方法可抽象方法
 *         5.abstract不能和static,final,native,private一起使用

 /*
 *  需求案例:
 *  	JavaEE 工程师		
 *  	Android 工程师	
 *  	抽出共性  定义个Develop开发类   work(){}
 */
public class Test_abstract {
	public static void main(String[] args) {
		// 测试抽象类可不可以创建对象
		// Develop d = new Develop(); //不能
		// 创建抽象类子类的对象
		JavaEE java = new JavaEE();
		java.work();
		Android an = new Android();
		an.work();

	}
}

// 定义接口
abstract class Develop {
	public abstract void work();
}

class JavaEE extends Develop {
	@Override
	public void work() {
		System.out.println("JavaEE工程师正在开发 B/S 软件...");
	}
}

class Android extends Develop {
	@Override
	public void work() {
		System.out.println("Android工程师正在开发C/S软件...");
	}
}

• 接口

 * 接口  interface
 *         接口是特殊的抽象类
 *              1.接口定义不再使用class,使用interface定义
 *              2.接口文件名还是以.java为结尾的,
 *                编译后的文件依然是以.class为结尾的.
 * 
 * 接口使用成员:
 *         成员属性:只能是一个静态的常量
 *             定义公式:public static final 数据类型 变量 = 变量值;
 *                      修饰符  静态的  最终的
 *                 以上关键字可以省略,省略也默认是public static final
 *         成员方法:
 *             定义公式:public abstract 返回值类型 方法名();
 *             不写默认为public abstract
 * 
 * 注意:
 *         1.接口不能实例化;
 *         2.如果想实例化这个接口,需要类去实现,使用implement;
 *         3.如果想实例化这个接口,需要重新接口中的所有抽象方法;
 *         4.一个具体类可以实现多个接口,不能继承接口,只能继承类,可以同时继承
 *     并且实现一个接口;
 *         5.一个接口可以继承多个接口,不可以实现一个接口,并且不能继承类
 *         6.接口多态,父接口指向实现类,调用的是类中重写的方法.

public interface Test_interface {
	int a = 15;

	// 抽象方法
	void xixi();

	void hengheng();
}

interface Demo {
	void xixi2();
}

interface Demo02 extends Demo, Test_interface {

}

class Demo03 implements Demo02 {

	@Override
	public void xixi2() {
		// TODO Auto-generated method stub

	}

	@Override
	public void xixi() {
		// TODO Auto-generated method stub

	}

	@Override
	public void hengheng() {
		// TODO Auto-generated method stub

	}

}

abstract class Test_interfaceImp implements Test_interface, Demo {
	@Override
	public void xixi() {
		System.out.println("嘻嘻...");
	}
}

class Test_interfaceImp2 extends Test_interfaceImp implements Demo {

	@Override
	public void hengheng() {
		System.out.println("哼哼...");
	}

	@Override
	public void xixi2() {
		// TODO Auto-generated method stub

	}

	// 新增方法
	public void newFunction() {
		System.out.println("新增方法...");
	}

}

class Test {
	public static void main(String[] args) {
		System.out.println(Test_interface.a);

		// 测试接口实例化-----不行
		// Test_interface in =new Test_interface() ;

		// 创建实例化对象
		Test_interfaceImp2 in = new Test_interfaceImp2();
		in.hengheng();
		in.xixi();
		in.xixi2();

		// 接口多态,编译看类型,运行找对象;实现,重写,父接口引用指向实现类对象
		Test_interface is = new Test_interfaceImp2();
		is.hengheng();

		// 向下转型
		Test_interfaceImp2 is2 = (Test_interfaceImp2) is;
		is2.newFunction();
	}
}