黑马程序员——继承2

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

< 今日心情 >越来越多的问题塞进脑袋里，头大慢慢消化^_^

一、 抽象类

抽象类是一个特殊的类，不能创建对象，只能被子类继承。

那么抽象类到底是什么呢？

1.抽象类的定义

当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。

只抽取功能定义，而不抽取功能主体。

例如：中国人，美国人，日本人都会说话，但是说到语言不同。

abstract class People //People被abstract修饰，表示这是一个抽象类
{
	String name;
	People(String name)
	{
		this.name=name;
	}
	abstract void speak();//speak被abstract修饰，这是一个丑行方法
							//“;”结尾，只需要speak的功能定义，不需要具体实现功能的方法体。
}

class Chinese extends People
{
	Chinese(String name)
	{
		super(name);
	}
	void speak()
	{
		System.out.println("我是："+name+",我说中国话。");
	}
}

class American extends People
{
	American(String name)
	{
		super(name);
	}
	void speak()
	{
		System.out.println("my name is "+name+",English!");
	}
}

class Japanese extends People
{
	Japanese(String name)
	{
		super(name);
	}
	void speak()
	{
		System.out.println(name);
	}
}

class AbstractDemo 
{
	public static void main(String[] args) 
	{
		Chinese c=new Chinese("李靖");
		c.speak();
		American a=new American("jeek");
		a.speak();
		Japanese j=new Japanese("松下介寿");
		j.speak();
	}
}

2.抽象类的特点

抽象类和抽象方法必须用abstract关键字来修饰。

抽象类中可以没有抽象方法，只是为了不被创建对象；

抽象方法必须放在抽象类中。

抽象方法只有方法声明，没有方法体，定义在抽象类中。

格式：修饰符abstract 返回值类型函数名(参数列表) ;

抽象类不可以创建对象。

抽象类本类就是描述抽象的事物，这样的事物不存在实体。

抽象类即使创建了对象，调用抽象方法没有意义，因为没有实现功能。

抽象类的子类要想创建对象，必须实现父类中所有的抽象方法，否则子类也是一个抽象类。

3.不能和abstract共存的关键字

final，被final修饰类不能被继承，被final修饰的方法不能被覆盖。

private，被private修饰的方法不能被子类知晓。

static，静态方法可以直接用类名调用，可是抽象方法并没有实际意义。

3.模板设计模式

概念：

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分；

那么这时就将不确定的部分暴露出去。由该类的子类去完成。

abstract class GetTime
{
	public final void getTime()
	{
		long start = System.currentTimeMillis();

		runcode();

		long end = System.currentTimeMillis();

		System.out.println("毫秒："+(end-start));
	}
	public abstract void runcode();

}


class SubTime extends GetTime
{

	public void runcode()
	{
		
		for(int x=0; x<4000; x++)
		{
			System.out.print(x);
		}
	}
}


class  TemplateDemo
{
	public static void main(String[] args) 
	{
		SubTime gt = new SubTime();
		gt.getTime();
	}
}

二、 接口

认知上，我们可以把接口当成一种特殊的抽象类。当抽象类中的方法都是抽象的时候，以接口的形式表现出来。

其实接口和抽象类是两回事，意义完全不同。

接口的特点：

固定的修饰符：

常量：public static final

方法：public abstract

接口的定义：

interface 接口名{}

接口和子类的链接方式：

implements 接口名。

注：java中不支持多继承，但是支持多实现，也就是implements后可以跟多个接口名。

接口的特点：

接口是对外暴漏的规则。

接口是功能的扩展。

接口可以用来多实现。

类与接口之间是实现关系，而且类可以 继承一个类的同时实现多个接口。

接口与接口之间可以有继承关系。

三、 多态

1.定义

某一类事物的多种存在形态。

其实就是用父类的类名表示子类的对象。

2.多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接收自己的子类对象。

abstract class People 
{
	String name;
	People(String name)
	{
		this.name=name;
	}
	abstract void speak();
}

class Chinese extends People
{
	Chinese(String name)
	{
		super(name);
	}
	void speak()
	{
		System.out.println("我是："+name+",我说中国话。");
	}
}

class American extends People
{
	American(String name)
	{
		super(name);
	}
	void speak()
	{
		System.out.println("my name is "+name+",English!");
	}
}

class Japanese extends People
{
	Japanese(String name)
	{
		super(name);
	}
	void speak()
	{
		System.out.println(name);
	}
}



class DuoTaiDemo 
{
	public static void main(String[] args) 
	{
		People c=new Chinese("李靖");//父类的引用指向子类的对象
		People a=new American("jeek");
		People j=new Japanese("松下介寿");
		See(c);//父类的引用接受子类的对象
		See(a);
		See(j);
	}
	public static void See(People p)
	{
		if(p instanceof Chinese)//判断p是否Chinese类
			System.out.println(p.name+"是个好同志。");
		else
			System.out.println(p.name+",你好！");
	}
}

3.多态的作用和前提

作用：

多态的存在提高了程序的扩展性和后期可维护性

前提：

需要存在继承或者实现关系

要有覆盖操作

3.多态的特点

成员函数：

编译时：（看左边）

要查看引用变量所属的类中是否有所调用的成员。

在运行时：（看右边）

要查看对象所属的类中是否有所调用的成员。

成员变量：（只看左边）

只看引用变量所属的类。

四、 内部类

1.定义

将一个类定义在另一个类的里面，对里面那个 类就称为内部类（内置类，嵌套类）。

2.访问规则

内部类可以直接访问外部类中的成员，包括私有。

之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this

外部类要访问内部类，必须建立内部类对象。

详细划分：

内部类定义在成员位置上：

可以被private static成员修饰符修饰。

被static修饰的内部类只能访问外部类中的静态成员。

内部类定义在局部位置上：

也可以直接访问外部类中的成员。

同时可以访问所在局部中的局部变量，但必须是被final修饰的。

其他类访问内部类中的成员：

内部类没有被static修饰：

该成员没有被static修饰：

先创建内部类的对象：外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

再使用成员：变量名.成员函数();

如果该成员被static修饰，内部类必须是静态的。

内部类被static修饰：

该成员没有被static修饰：

外部类名.内部类名 变量名=new 外部类名.内部类名();

变量名.成员函数();

该成员被static修饰：

外部类名.内部类名.成员函数();

class People
{
	String name="peek";
	class Heart
	{
		void run()
		{
			System.out.println("hi,"+name);
			System.out.println("我跳，我跳，我跳跳跳。");
		}
	}
	void show()
	{
		Heart h = new Heart();
		h.run();
	}
}
class InnerClass 
{
	public static void main(String[] args) 
	{
		People p=new People();
		p.show();
		System.out.println("---------------------");
		p.new Heart().run();
		//new People().new Heart().run();
	}
}

3.匿名内部类

匿名内部类是内部类在局部位置时的简写模式；

定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

匿名内部类可以理解成多态的一种形式。

匿名内部类格式：

new 父类或接口

{

覆盖父类方法，或实现接口

}.父类或接口中的方法名();

abstract class GetTime
{
	public final void getTime()
	{
		long star=System.currentTimeMillis();
		run();
		long end =System.currentTimeMillis();
		System.out.println("毫秒："+(end-star));
	}
	abstract void run();
}
class NoNameClass 
{
	public static void main(String[] args) 
	{
		new GetTime(){
			public void run()
			{
				for(int i=0;i<100;i++)
				{
					System.out.println("good boy!");
				}
			}
		}.getTime();
	}
}