黑马程序员-Java面向对象3

-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------

 

1.多态(掌握)

1.1对象在不同时刻表现出来的不同状态。

举例：水(冰，水，水蒸气)

1.2多态的前提

A:要有继承或者实现关系。
B:要有方法的重写。(否则没有多态的必要)
C:要有父类引用或者父接口引用指向子类对象。
注意：多态有三种体现形式
类多态;抽象类多态;接口多态

1.3多态中的成员特点：

A:成员变量

编译看左边，运行看左边。(变量不存在重写)

B:成员方法

编译看左边，运行看右边。

举例：孔子装爹。(穿老子衣服,说自己的话)

我的理解:(用模具来理解)

父类引用指向子类对象.这个是多态最常见的表现形式,可以这么想.父类,子类,都是一个模具.成员变量,就像是可在模具上的信息,成员方法就像是模具上各种大大小小的凹槽,用来填充料.
当生成一个父类引用,就是生成了一个父类的模具;此时如果指向一个子类对象,就是用子类的模具先做一个产品出来,然后再放到父类上塞进去.这个时候,因为子类是继承父类的,父类的凹槽子类中肯定全有,而子类中还可能会多出更多凹槽,所以在子类产品塞上父类的模具的时候,对于那些子,父类都有的凹槽,子类产品是能塞进去的.没有的就只能暂且留在模具外面.而成员变量,就是文字,这样,拿的谁的模具,文字就是谁的.这样就是完整的解释了:父类引用,指向子类对象了.
而在这个情况下,想调用子类特有的功能,就需要进行向下转型.想,我们本来就是用子类模具做出来的产品,虽然在塞到父类模具中是,那些子类特有凹槽做出来的部分暂且留在父类模具外面,但是如果这个时候我们再把它塞回子类模具,怎么样,是不是就又全能塞进去了.这就是向下转型,能够使用子类特有方法了.

1.4多态的弊端：

父类(接口)引用不能使用子类特有功能。
为了解决这个弊端，我们需要向下转型。
Fu f = new Zi(); //向上转型
Zi z = (Zi)f; //向下转型
Zi z = new Zi();

1.5多态的好处：

可以提高代码的扩展性和可维护性。

2.抽象类(理解)

2.1定义:

如果多个类中存在相同的方法声明，而方法体不一样，我们就可以只提取方法声明。
如果一个方法只有方法声明，没有方法体，那么这个方法必须用抽象修饰。
而一个类中如果有抽象方法，这个类必须定义为抽象类。

2.2抽象类的特点

A:抽象类和抽象方法必须使用abstract修饰
B:抽象类不能被实例化
C:抽象类有抽象方法，用于子类实例化使用
D:如果一个类是抽象类，那么，继承它的子类
要么是抽象类。
要么重写所有抽象方法。

2.3抽象类的成员特点

A:成员变量  可以变量，也可以是常量
B:构造方法  有构造方法
C:成员方法  可以是抽象方法，也可以是非抽象方法

2.4抽象类的几个小问题

A:抽象类不能被实例化，为什么有构造?
他的构造用于子类实例化使用。(Object类都有个空参构造)
B:一个类没有抽象方法，为什么定义为抽象类?
不想被实例化。
C:abstract不能和哪些关键字共存。
final:final修饰的方法不能被重写,final修饰的类不能被继承.
private:私有方法在子类中无法访问,无法被复写.
static:静态的方法在方法加载时就存在,抽象方法静态没有意义.

2.5案例：

      老师案例      学生案例

/*
具体事务：基本班学员，就业班学员
共性：姓名，年龄，学习，睡觉
*/

abstract class Student
{//建立学生类,抽象类,有私有属性姓名,年龄.有抽象方法学习,有普通方法睡觉.
	private String name;
	private int age;

	Student(){}

	Student(String name,int age)
	{
		this.name=name;
		this.age=age;
	}

	abstract void study();

	void sleep()
	{
		System.out.println("我是传智学员,我要睡觉.");
	}

	void show()
	{
		System.out.println("该学生叫:"+name+"\t该学生年龄为:"+age);
	}
}

class BaseStudent extends Student
{
	BaseStudent(){}

	BaseStudent(String name,int age)
	{
		super(name,age);
	}

	void study()
	{
		System.out.println("基础班学员学习基础知识.JavaSE");
	}
}

class AdvStudent extends Student
{
	AdvStudent(){}

	AdvStudent(String name,int age)
	{
		super(name,age);
	}

	void study()
	{
		System.out.println("就业班学员学习高级知识.JavaEE");
	}

}

class StudentTest_abstract
{
	public static void main(String[] args)
	{
		/*
		Student b=new BaseStudent("张三",18);
		b.show();
		b.sleep();
		b.study();
		System.out.println("----分--------割---------线---");
		Student a=new AdvStudent("李四",20);
		a.show();
		a.sleep();
		a.study();
		System.out.println("----分--------割---------线---");
		System.out.println("----分--------割---------线---");
		*/
	}
}

3.接口(理解)

3.1定义

如果一个抽象类中的方法都是抽象的，这个时候，java就提供了一种更抽象的表示形式：接口。
接口：interface
实现：implements
格式：
interface 接口名{}
class 类名 implements 接口名 {}

3.2接口的特点：

A:接口不能被实例化。
B:一个类如果实现了接口：
      要么是抽象类。
      要么实现接口中的所有方法。

3.3接口的成员特点：

A:成员变量  只能是常量。默认修饰符 public static final
B:成员方法  只能是抽象方法。默认修饰符 public abstract
推荐：永远手动给出修饰符。

3.4接口的思想特点：

A:对外暴露的规则
老师的原话,但是我对这个思想的理解有些模糊,后来想了想,对外暴露的规则,可以这么理解,接口就是描述一项功能,或者行为,当一个类需要这个功能,就通过实现这个接口.当然,功能的实体是需要这个类重新定义的.接口就像是让你了解需要这个功能,你得遵守那些规则.接口就是这个对外暴露的让你知道的规则,他没必要具有这个功能的主体.
B:是功能的扩展
C:降低耦合度(关联度)
     耦合：类与类的关系
     内聚：类自己完成某件事情的能力(独立度)
高内聚，低耦合。
D:接口可以多实现。(想想啊,反正接口都是抽象方法,不存在类中的同名方法指向不明确的问题.)

3.5类，接口的关系

A:类与类
继承关系,只能单继承，可以多层继承。
B:类与接口
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时实现多个接口。
C:接口与接口
继承关系，可以单继承，也可以多继承。

3.6抽象类和接口的关系

3.7案例：运动员和教练的案例。

/*
乒乓球,篮球运动员,教练.
乒乓球球员教练都需要会英语,出国交流.
思路分析:
1.运动员,教练都是人,都有姓名,年龄--->抽象类,人.
2.篮球运动员,乒乓球运动员都是运动员--->父类,运动员.
3.篮球教练,乒乓球教练都是教练--->父类,教练.
4.出国交流会英语--->接口,会英语.
*/
class Person//运动员,教练都是人,都有姓名,年龄--->抽象类,人.
{
	private String name;
	private int age;
	
	Person(){}

	Person(String name,int age)
	{
		this.name=name;
		this.age=age;
	}

	void show()
	{
		System.out.println(name+"\t"+age+"岁");
	}
}

interface SpeakEnglish//出国交流会英语--->接口,会英语.
{
	public abstract void speak();
}

abstract class SportsMan extends Person//篮球运动员,乒乓球运动员都是运动员--->父类,运动员.
{
	SportsMan(){}

	SportsMan(String name,int age)
	{
		super(name,age);
	}

	abstract void doSports();
}

abstract class Coach extends Person//篮球教练,乒乓球教练都是教练--->父类,教练.
{
	Coach(){}

	Coach(String name,int age)
	{
		super(name,age);
	}
	
	abstract void teach();
}

class BasketballSportsman extends SportsMan
{
	BasketballSportsman(){}

	BasketballSportsman(String name,int age)
	{
		super(name,age);
	}

	void doSports()
	{
		System.out.println("篮球运动员,练习打练球.");
	}
}

class PingpangSportsman extends SportsMan implements SpeakEnglish
{
	PingpangSportsman(){}
	
	PingpangSportsman(String name,int age)
	{
		super(name,age);
	}

	void doSports()
	{
		System.out.println("乒乓球运动员,练习打乒乓球.");
	}
	
	public void speak()
	{
		System.out.println("乒乓球运动员精通英语.");
	}
}

class BasketballCoach extends Coach
{
	BasketballCoach(){}

	BasketballCoach(String name,int age)
	{
		super(name,age);
	}

	void teach()
	{
		System.out.println("能够训练篮球运动员打篮球.");
	}
}

class PingpangCoach extends Coach implements SpeakEnglish
{
	PingpangCoach(){}

	PingpangCoach(String name,int age)
	{
		super(name,age);
	}

	void teach()
	{
		System.out.println("能够训练乒乓球运动员打篮球.");
	}

	public void speak()
	{
		System.out.println("乒乓球教练精通英语.");
	}
}

class SportsmanTest
{
	public static void main(String[] args)
	{
		BasketballSportsman a1=new BasketballSportsman("姚明",29);
		a1.show();
		a1.doSports();
		System.out.println("----------分割线-----------");
		BasketballCoach a2=new BasketballCoach("姚明他老子",50);
		a2.show();
		a2.teach();
		System.out.println("----------分割线-----------");
		PingpangSportsman a3=new PingpangSportsman("邓亚萍",30);
		a3.show();
		a3.doSports();
		a3.speak();
		System.out.println("----------分割线-----------");
		PingpangCoach a4=new PingpangCoach("邓亚萍他老子",49);
		a4.show();
		a4.teach();
		a4.speak();
	}
}

-----------------------android培训、java培训、java学习型技术博客、期待与您交流！----------------------

详情请查看：http://edu.csdn.net/