J2SE的学习——面向对象的接口和多态性

1、接口

1、接口是一种特殊的“抽象类”，没有普通方法，由全局常量和共有的抽象方法组成。 接口是用关键字interface来定义的。
代码：

下面写一个测试类

提示信息：必须要实现接口中的抽象方法，直接点下面的解决方案中的Add添加就行了
Add之后的效果

一般情况下这个abstract是直接省略的。

2、实现接口的话可以实现一个或者多个接
三个类的源代码在这里：

Demo1如下
    package page24;

public interface Demo1 {
	//全局常量
	public static final String name="张三";
	/**
	 * 定义一个抽象方法
	 * 但是在interface中，abstract是可以省略的
	 */
	public void a();
}

Demo2如下：

package page24;

public interface Demo2 {
	//全局常量
		public static final String name1="李四";
		/**
		 * 定义一个抽象方法
		 * 但是在interface中，abstract是可以省略的
		 */
		public abstract void b();
}

测试类：Text

package page24;

public class Test implements Demo1,Demo2{

@Override 	
public void a(){ 		
 		System.out.println("重写a的抽象方法"); 
 	}

   @Override 	
public void b(){ 		
   		System.out.println("重写b的抽象方法"); 	
   	}
public static void main(String[] args) { 		
      Test t=new Test();
      t.a();
      t.b(); 		//直接获取子类中的共有的静态方法
      System.out.println(Demo1.name);
      System.out.println(Demo2.name1);
      	}
      
 }

效果：

因此：继承是唯一的，只能继承一个，但是接口可以写多个上去。

4、继承类和实现接口：先继承，后实现接口 简单的写一个C类

用测试类去继承这个类，注意，这个是类，不是接口。
没有出现报错，必须要先继承，再写接口上去。
把新继承上去的子类的方法进行输出
在这个可以看到，接口个子类继承的方法是可以用的，如果子类是抽象类，也是要把抽象方法重写的，唯一的区别是interface中的abstract是可以省略的，真正在做项目的时候，这个是直接省略掉的。

5、接口的继承：接口可以多继承
重新写一个测试类Test2和一个接口D，用D这个接口继承Demo1和Demo2这两个接口，（注：这里的Demo1和Demo2就是Test1中引入的，没有改变）再在Test2中引入D接口
Test2代码

package page24;

public class Test2 implements D{

	@Override
	public void a() {
		System.out.println("我来自于D接口中继承的Demo1接口中的a方法");
	}

	@Override
	public void b() {
		System.out.println("我来自于D接口中继承的Demo2接口中的b方法");
	}

	@Override
	public void d() {
		System.out.println("我来自于D接口中自带的d方法");
	}

	public static void main(String[] args) {
		Test2 t=new Test2();
		t.a();
		t.b();
		t.d();
	}
}

接口D的代码：

package page24;

public interface D extends Demo1,Demo2{
	public void d();
}

执行效果Test2的效果

因此：类可以继承一个类，或者引入多个接口，接口可以继承多个接口！

2、多态性

Java中的多态性表现：

1. 方法的重载和重写
2. 可以用父类的引用指向子类的具体实现，而且可以随时更换为其他子类的具体实现

1、创建一个父类的对象和两个子类的对象，然后分别用两个子类继承父类，然后在测试类中进行测试。 如下： 动物父类
package page24;

public class Animal {
	public void say() {
		System.out.println("我是一个动物！");
	}
} 子类猫

package page24;

public class Cat extends Animal{
	//重写一下父类的方法
	public void say() {
		System.out.println("我是一只猫!");
	}
}

子类狗 package page24;

public class Dog extends Animal{ //重写一下父类的方法 public void say() {
System.out.println(“我是一只狗！”); } }

测试类

package page24;

public class Test3 {
	public static void main(String[] args) {
		//正常情况下的使用
		Dog dog=new Dog();
		dog.say();
		
		Cat cat=new Cat();
		cat.say();
		System.out.println("以下的部分都是用多态方法输出的。");
		/*
		 * 多态的使用
		 * 父类的引用指向Dog子类的具体实现
		*/
		Animal animal=new Dog();
		//这里调用的是Dog里面的方法，如果Dog中没有重写，那么就会输出父类中的say方法
		animal.say();
		
		//更换实现：多态的应用特性
		animal=new Cat();
		animal.say();
	}
} 

运行效果

2、对象的转型问题：

转型方向	转型前对象称呼	箭头标记	转型前对象称呼	安全性
向上转型	子类对象	——>	父类对象	安全的
向下转型	父类对象	——>	子类对象	不安全

上面已经写到的这种，这就是子类对象转到父类对象

这种是安全的
下面是父类转到子类
这种是不安全的，这里得强制转化，和数据的强制转化有点像，我们只能从低等级都高等级的转化，不能从高到底转化，从高到底的转化会出现一系列的问题。

3、多态中对接口的使用（这是重点，实际项目开发不是继承类，而是引入一个接口）
创建一个People接口，一个Student类，一个Teacher类，这两个类分别引入People这个接口，然后创建一个Test4测试类
People接口：

package page24;

public interface People {
	public void say();
} Student类：

package page24;

public class Student implements People{

	@Override
	public void say() {
		System.out.println("我是学生");
	}

}

Teacher类：

package page24;

public class Teacher implements People{

	@Override
	public void say() {
		System.out.println("我是老师");
	}

}

Test4测试类：

因为是接口，不能直接被实例化。
下面这样写就对了。

代码：

package page24;

public class Test4 {
	public static void main(String[] args) {
		//这里用到的多态的知识和接口的知识！
		//并且转型是向上转型
		//父类的引用，指向子类的具体实现！
		People p1=new Student();
		p1.say();
		
		//随时更换具体实现
		p1=new Teacher();
		p1.say();
	}
} 

结果：

这样就把多态和接口的知识引入了，正常的开发，都是多态和接口配合使用，不是多态和继承类配合使用！但是继承也是可以在混进去的，接口可以被继承，具体看发挥了，上面讲了混合的使用！page24