黑马程序员---多态

 ------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

  第一讲 多态

一,多态
    1.父类的引用指向它的某个子类的对象。这种形式就叫：多态
    2.多态的前提和体现：
1).前提：一定要有继承关系；
要有方法的重写；
用父类的引用指向子类的对象

class Animal
{
}
class Cat extends Animal
{
	
}
class Dog extends Animal
{
}
class Employee
{
}
class Demo 
{
	public static void main(String[] args) 
	{
		//正常情况下，实例化一个Cat对象
		Cat c = new Cat();
		//使用多态，父类的引用指向子类的对象
		Animal a = new Cat();//OK的
		Animal a2 = new Dog();//OK的

		Animal a3 = new Employee();//编译错误。多态必须要有继承关系；
	}
}

二,多态中成员的访问特点
1.多态时，通过父类的引用访问的必须是父类中定义的，不能访问子类特有的成员；
二.发生覆盖时：
1.普通成员变量：编译看左边：编译时，父类中必须要有此成员，否则编译错误
运行看左边：运行后，打印的，也是父类的内容；

2.普通成员方法：
编译看左边: 编译时，父类中必须要有此成员，否则编译错误
运行看右边：运行时，运行时的是"子类中的方法"


3.静态成员方法：静态的，跟"类"有关，跟"对象"无关，不存在动态绑定：
编译看左边：编译时，父类中必须要有此成员，否则编译错误
运行看左边：运行后，打印的，也是父类的内容；


总结一句话：多态时，访问的成员，父类中必须要有；只有成员方法是调用的子类的，其它都是父类的

三,多态好处与弊端
 好处:提高了程序的维护性(由继承保证)
 弊端:多态时，不能访问子类特有的成员

 class A
{

}
class B extends A
{
	void show(){
		System.out.println("B --> show()");
	}
}

class Demo 
{
	public static void main(String[] args) 
	{
		A a = new B();
		a.show();//编译错误，不能访问子类特有的成员；
	}

三,多态的类型转换
   1.向上转型：父类的引用指向了子类对象。隐式的自动转换
class A{}
  class B extends A{}
main(){
A a = new B();//向上转型
}
 特点：
1.多态；
2.访问的只能是父类中定义的成员，不能访问子类特有的成员；
   2.向下转型：如果确定父类类型指向了某个子类的对象，那么可以将这个父类型的引用
           强制转换为它所指向的子类类型的引用。


注意：向下转型时，由于有可能会发生ClassCastException。所以，为了安全起见，Java为我们提供了一个
     判断的运算符：instanceof
 1.双目运算符：
 2.使用格式：变量 instanceof 某个类类型
 3.它会返回一个boolean值，如果"变量"是"某个类类型"，那么返回true,否则返回false;
 4.在强制转换前，可以使用这个操作符进行判断；

class A
{
	void show(){
		System.out.println("A-->show()");
	}
}
class B extends A
{
	void method(){
		System.out.println("B-->method()");
	}
}
class C extends A
{
	
}
class Demo 
{
	public static void main(String[] args) 
	{
		A a = new B();//隐式的，向上转型
		a.show();
	///	a.method();//不可以，编译错误，不能访问子类特有成员；
		
		//可以将变量a强制转换为B类类型；
		B b = (B)a;
		//转换后，就可以访问子类特有的成员了
		b.method();

	//	C c = (C)a;//不可以。B和C没有关系，不能强制转换。编译可以通过，运行时异常：ClassCastException
		System.out.println("将子类类型自动提升为父类类型：");
		A a2 = b;//可以直接赋值，隐式的自动转换
		a2.show();

		//在向下转型时，使用instanceof操作符进行判断
		if(a instanceof B){
			System.out.println("a 指向的是 B的对象，可以安全向下转换为B类型");
			B b2 = (B)a;

		}
		if(a instanceof C){
			System.out.println("a 指向的是 C的对象，可以安全向下转换为C类型");
			C c2 = (C)a;
		}
	}
}

第二讲  抽象类

一,抽象类
    1.有些时候，有些父类中的一些方法，会被每个子类都要重写，
 所以此时，父类中这个方法的定义就没有意思。


    2.这时，可以将父类中的这个方法定义为"抽象的方法"；只有方法声明，没有方法体；
 需要一个关键字：abstract
 例如：
abstract void show();//直接分号结束，没有大括号；
    3.如果父类中，有一个方法是"抽象方法"，那么这个类也必须是"抽象的"，在类的定义处
 需要使用关键字：abstract

    4.如果一个类是"抽象类"，就意味着这个类"不能被实例化"了。

    5.一个抽象类，就是用来做"父类"，被其它类"继承"的。

 abstract class Person
{
	abstract void show();
}
class Student extends Person
{
	//重写show
	void show(){
		System.out.println("我是黑马的一名学生");
	}
}
class Teacher extends Person
{
	//重写show
	void show(){
		System.out.println("我是黑马的一名教师");
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		Person p1 = new Student();
		p1.show();//子类


	}
}

二,抽象类的特点
    1.抽象类和抽象方法，使用关键字：abstract修饰；
    2.抽象类中，可以什么都不定义。包括抽象方法；
    3.抽象类中的可以有什么东西：
1).成员变量：
2).成员方法；
3).构造方法：
4).抽象方法：
    4.子类继承一个抽象类仍然使用:extends ，而且仍然是"单继承"
    5.如果一个子类，继承了一个抽象类，那么必须要全部重写父类中的"抽象方法"，可以不重写或不全部重写，
 那么这个子类也必须是"抽象类"。换句话说：一个抽象类可以继承自一个抽象类；

abstract class Person
{
	//成员变量
	private int num = 10;
	//成员方法
	public void show(){
		System.out.println("Person --> show()");
	}
	//构造方法
	Person(){
		System.out.println("Person的无参构造方法");
	}
	//抽象方法
	public abstract void eat();
	public abstract void sleep();
	public abstract void method();
}
//一个类，继承自一个抽象类后，必须重写抽象类中的所有抽象方法
class Student extends Person
{
	public void eat(){
		System.out.println("烤冷面");
	}
	
	public void sleep(){
		System.out.println("我睡觉");
	}
	public void method(){
		System.out.println("method方法");
	}
}
//
abstract class Teacher extends Person
{
	//只重写一个方法。那么这个类，也必须是一个抽象类
	public void eat(){
		
	}

	//其它两个抽象方法没有重写

}

class Demo 
{
	public static void main(String[] args) 
	{
	//	Person p = new Person();
		Person p = new Student();
	}
}

第三讲 接口

一,定义
    1.当一个抽象类中没有实现的方法，而只有抽象方法时，可以将这个类定义为：接口；
 使用关键字：interface
2.接口跟抽象类一样，不能被"实例化"，用来做父类的；
3.子类是"实现接口"，使用关键字：implements
4.如果一个类实现某个接口，那么必须全部重写接口的抽象方法；
5.接口中可以定义什么：JDK8以前：
  1.成员变量：必须是全局常量：必须被声明为：public static final，可以不这样声明，但编译器会自动添加
interface IA{
int num = 10;//隐式的自动声明为：public static final int num = 10;
}
     2.成员方法(抽象方法)：必须是抽象方法，必须被声明为：public abstract。可以不这样声明，但编译器会自动添加
interface IA{
void show();//隐式的自动声明为：public abstract void show();

}

interface IService
{
	abstract void add();
	abstract void update();
	abstract void delete();
	abstract void find();
}
class StudentService implements IService
{
	//必须全部重写接口中的抽象方法
	public void add(){
	}
	public void update(){
	}
	public void delete(){
	}
	public void find(){
	}
}
class Demo 
{
	public static void main(String[] args) 
	{
		//使用接口多态
		IService is = new StudentService();
		is.add();//子类的
	}
}

二,接口的特点
     1.定义接口：关键字：interface
 格式：interface 接口名
     2.子类实现：关键字：implements
     3.一个子类，可以同时实现多个接口。格式：
class SubA implements IA,IB,IC{
}
 必须要重写三个接口中的所有抽象方法；
     4.一个接口，可以"继承自"另一个接口，而且可以"多继承"：使用关键字extends
     5.一个抽象类，仍然是实现接口，而且可以实现多个接口，而且可以不重写或不全部重写接口中的方法。因为此类本身就是个"抽象的"
     6.一个类可以同时继承自一个父类，并同时实现一个或多个接口：一定要先"继承"，后"实现"
三,接口与抽象类的区别
相同点：都不能被实例化；


区别：


1.定义关键字：
1).接口：interface
2).抽象类：abstract class
2.子类使用时：
1).接口：implements(实现):可以同时实现多个接口
2).抽象类: extends(继承)：单继承
3.内部成员：
1).接口：
A.成员变量：public static final
B.抽象方法：public abstract
2).抽象类：
A.成员变量
B.成员方法
C.构造方法
D.抽象方法；
4.接口和接口之间：继承关键，可以多继承
 抽象类和抽象类之间：继承关系，单继承；