多态、抽象类、接口

一、object类

• Object类是所有Java类的根基类
• 如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类

• 例如：public class Student{} 等价于 public class Student extends Object

1）、toString()方法

• toString()把对象以字符串的形式打印
• 在打印对象的应用时,默认调用这个对象的toString()
• 如果打印对象时想要显示对象的基本信息|所有成员属性的值,去对应类中重写toString()方法

class Person{
//重写toString()方法,因为Person是Object类型的子类,就可以重写父类的toString()方法
	//显示所有成员属性的值
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
}

2）、equals()方法

• Object的equals方法默认比较的是引用（对象地址）

 public boolean equals(Object obj) {
        return (this == obj);
}

注：如果子类有自定义的比较规则,先要根据内容(成员属性的值)比较对象是否相等,可以在子类中重写equals()方法
       String等类已经重写了equals()方法,比较对象的内容,如果是自定义类,需要程序员自己重写

//重写equals方法
public boolean equals(Object obj) {
		//增强程序健壮性  如果对象的地址都相同,就是一个对象
		if (this == obj) {
            return true;
        }
		//判断参数是否为Person类型的对象
		if(obj instanceof Person){
			Person p=(Person)obj;
			
			if(this.id==p.id && name.equals(p.name) && this.age==p.age && this.gender==p.gender){
				return true;
			}
		}
		
		return false;
	}

3）、casting对象转型

子类对象可 以 当作基类的 对 象来使用， 称 作向上转型
(upcasting)，反之称为向下转型(downcasting)

基本数据类型: 自动类型提升 强制类型转换–> 小范围类型 引用 = (小范围类型 )大范围类型;

引用数据类型: 向上转型 向下转型 大范围: 父类|父接口 小范围:子类|实现类

class Test{
	public static void main(String[] args){
		A a2 = new B();		//自动向上转型
		B b = (B)a2;  	//向下转型
		A a3 = (A)b;	//向上转型
	}
}
class A{}
class B extends A{}

二、多态

1）、定义

一种事物的多种形态|多种表现形式

2）、多态的前提

• 子父类的继承关系
• 方法的重写
• 父类引用指向子类对象

public class PhyDemo01 {
	public static void main(String[] args) {
		//父类的引用执行子类的对象
		Person s=new Student();
		s.haha();
	}

}

class Person{
	public static void haha(){
		System.out.println("智者微笑");
	}
	
}

class Student extends Person{
	public static void haha(){
		System.out.println("傻笑");
	}

}

3）、多态成员的特点

成员变量	编译运行找父类|看左边|找类型
成员方法	编译时看左边，运行时看右边
静态方法	编译时看左边，运行时也看左边

public class PhyDemo01 {
	public static void main(String[] args) {
		//父类的引用执行子类的对象
		Person s=new Student();
		s.haha();   //智者微笑
		s.hehe();	//呵呵一笑
		System.out.println(s.a);  //a=5
		
	}

}

class Person{
	int a=5;
	
	public static void haha(){
		System.out.println("智者微笑");
	}
	
	void hehe(){
		System.out.println("呵一笑");
	}
}

class Student extends Person{
	int a=10;
	
	public static void haha(){
		System.out.println("傻笑");
	}
	//新增方法
	void hehe(){
		System.out.println("呵呵一笑");
	}
	
}

4）、多态的优缺点

优点：可以提高可维护性，提高代码的可拓展性

缺点：无法直接访问子类所特有的成员 （可以通过向下转型实现）

三、抽象类

1）、abstract关键字

(1)、用途：用于修饰方法和类

(2)、抽象方法：不同类的方法是相似，但是具体的内容又不太一样，所以只抽取他的声明，没有具体的方法体，没有具体丰富他的符就是抽象方法。

(3)、抽象类：有抽象方法的类必须是抽象类。

注：一个类继承了抽象类需要重写他所有的抽象方法，否则这个类就得是抽象类

2）、抽象类的特点

• 抽象方法只能存在于抽象类里面
• 抽象类不能实例化（不能创建对象）
• 抽象类中可以有非抽象的方法
• 抽象方法必须被重写
• abstract不能和final,static,private,native一起使用

public class Test {
	public static void main(String[] args) {
//		Animal a = new Animal();	//抽象类不能实例化
	}
}
//抽象类
abstract class Animal{
    //抽象方法
	public abstract void eat();
    //具体方法
    public void sleep(){
        System.out.println("我是具体方法");
    }
}

class Cat extends Animal{
    //重写
	public void eat(){
		System.out.println("猫喜欢吃鱼");
	}
}
//正确
abstract class Dog extends Animal{
	
}

//报错   一个类继承了抽象类需要重写他所有的抽象方法，否则这个类就得是抽象类
//class Dog extends Animal{
//	
//}				

四、接口

1）、定义

接口是用于处理继承单一局限性的。interface：定义接口；implements：实现接口

2）、接口的成员特点

• 只能有抽象方法
• • 默认且只能使用public & abstract 修饰方法
• 只能有常量
• • 默认使用public & static & final 修饰成员变量

注：

• 接口不能创建对象（不能实例化）
• 类与接口的关系是实现关系，一个类实现一个接口必须实现它所有的方法

public class Test {
	public static void main(String[] args) {
//		Animal a = new Animal(); //报错  不能实例化
	}
}

//接口
interface Animal{
//	int num;	//报错  只能有常量
	int num=20;
	public void eat();
}

//类与接口是实现关系
class Dog implements Animal{  

	@Override
	public void eat() {
		System.out.println("狗拿耗子");
	}
	
}

• 接口可以多继承接口,但接口不能实现接口
• 类和接口之间,只能用类实现接口,接口不是实现|继承类的
• 接口可以发生接口多态,类可以发生类的多态

public class Interface2 {
	public static void main(String[] args) {
		
	}
}

interface A{
	public void run();
}
interface B extends A{
	public void eat();
}
interface C extends A,B{ 
	//接口与接口之间多继承
}

//interface B implements A{} //报错	接口不能实现接口

class Demo implements C{

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

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

3）、接口的优点

1. 接口可以多实现,只能单继承
2. 解耦 (高内聚低耦合)
3. 定义开发规范
4. 提高代码的复用性