Java面向对象继承（下）

Java面向对象继承（下）

知识概要：

（1）抽象类

                          1.1 抽象类概述
                          1.2 抽象类的特点
                          1.3 抽象类举例代码讲解
                          1.4 抽象类相关问题

（2）模板方法模式

2.1 模板设计模式的概念

2.2 模板设计模式的演示

（3）接口

3.1 接口的格式

3.2 接口的特点

（4）多态

（1）抽象类

抽象类概述

 抽象定义：
• 抽象就是从多个事物中将共性的，本质的内容抽取出来。
• 例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

 抽象类：
• Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类

就是抽象类。

 抽象方法的由来：
• 多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取

功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
• 例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明

确吼叫的细节。

抽象：看不懂的功能内容。

       抽象类的特点：
        1，抽象方法一定在抽象类中。
        2，抽象方法和抽象类都必须被abstract关键字修饰。
        3，抽象类不可以用new创建对象。因为调用抽象方法没意义。
      4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。
       如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

       抽象类和一般类没有太大的不同。
       该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。
       这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。通过抽象方法来表示。

抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法，抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

abstract class Student
{
	abstract final void study();

	void sleep()
	{
		System.out.println("躺着");
	}
}


class ChongCiStudent extends Student
{
	void study()
	{
		System.out.println("chongci study");
	}
}

class BaseStudent extends Student
{
	void study()
	{
		System.out.println("base study");
	}
}

class AdvStudent extends Student
{
	void study()
	{
		System.out.println("adv study");
	}
}

class AbstractDemo 
{
	public static void main(String[] args) 
	{
		
		new BaseStudent().study();
	}
}

抽象练习：

<span style="font-size:18px;">/*
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。

员工类：name id pay

经理类：继承了员工，并有自己特有的bonus。


*/

abstract  class Employee
{
	private String name;
	private String id;
	private double pay;

	Employee(String name,String id,double pay)
	{
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	
	public abstract void work();

}



class Manager extends Employee
{
	private int bonus;
	Manager(String name,String id,double pay,int bonus)
	{
		super(name,id,pay);
		this.bonus = bonus;
	}
	public void work()
	{
		System.out.println("manager work");
	}
}

class Pro extends Employee
{
	Pro(String name,String id,double pay)
	{
		super(name,id,pay);
	}
	public void work()
	{
		System.out.println("pro work");
	}
}



</span>

abstract 关键字，和哪些关键字不能共存？
final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。

private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写，而抽象方法出现的就是需要被复写

static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了，可是抽象方法运行没意义。

抽象类中是否有构造函数？
有，抽象类是一个父类，要给子类提供实例的初始化。

（2）模板方法模式

需求：获取一段程序运行的时间。

原理：获取程序开始和结束的时间并相减即可。

获取时间：System.currentTimeMillis();

当代码完成优化后，就可以解决这类问题。

这种方式，模版方法设计模式。

        什么是模版方法呢？
        在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，
        那么这时就将不确定的部分暴露出去。由该类的子类去完成。

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) 
	{
		//GetTime gt = new GetTime();
		SubTime gt = new SubTime();
		gt.getTime();
	}
}

（3）接口讲解

格式：
interface { }

    接口中的成员修饰符是固定的。
      •成员常量：public static final
       •成员函数：public abstract

记住：接口中的成员都是public的。

      接口：是不可以创建对象的，因为有抽象方法。
              需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。
                否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

interface Inter
{
	public static final int NUM = 3;
	public abstract void show();
}

interface InterA
{
	public abstract void show();
}

class Demo
{
	public void function(){}
}

class Test extends Demo implements Inter,InterA
{
	public void show(){}
}


interface A
{
	void methodA();
}
interface B //extends A
{
	void methodB();
}

interface C extends B,A
{
	void methodC();
}

class D implements C
{
	public void methodA(){}
	public void methodC(){}
	public void methodB(){}
}


class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		Test t = new Test();
		System.out.println(t.NUM);
		System.out.println(Test.NUM);
		System.out.println(Inter.NUM);

	}
}

     抽象类和接口异同：
   相同：
    1，都可以在内部定义抽象方法。
    2，通常都在顶层。

3，都不可以实例化，都需要子类来实现。

不同点：

   1，抽象类中可以定义抽象方法和非抽象方法，而接口中只能定义抽象方法。
   2，接口的出现可以多实现。抽象类只能单继承。也就是说：接口的出现避免了单继承的局限性。
   3，继承和实现的关系不一致。继承：is a，实现：like a

（4）多态

多态：可以理解为事物存在的多种体现形态。

人：男人，女人

动物：猫，狗。

猫 x = new 猫();

动物 x = new 猫();

1，多态的体现

        父类的引用指向了自己的子类对象。
         父类的引用也可以接收自己的子类对象。
     2，多态的前提
          必须是类与类之间有关系。要么继承，要么实现。
          通常还有一个前提：存在覆盖。

3，多态的好处
多态的出现大大的提高程序的扩展性。

4，多态的弊端：
提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

在多态中成员函数的特点：

1.在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

2.在运行时期：参阅对象所属的类中是否有调用的方法。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

        在多态中，成员变量的特点：
      无论编译和运行，都参考左边(引用型变量所属的类)
      在多态中，静态成员函数的特点：

无论编译和运行，都参考做左边。

/*
需求：
电脑运行实例，
电脑运行基于主板。
*/


interface PCI
{
	public void open();
	public void close();
}

class MainBoard
{
	public void run()
	{
		System.out.println("mainboard run ");
	}
	public void usePCI(PCI p)//PCI p = new NetCard()//接口型引用指向自己的子类对象。
	{
		if(p!=null)
		{
			p.open();
			p.close();
			
		}
	}
}


class NetCard implements PCI
{
	public void open()
	{
		System.out.println("netcard open");
	}
	public void close()
	{
		System.out.println("netcard close");
		method();
	}
	
}
class SoundCard implements PCI
{
	public void open()
	{
		System.out.println("SoundCard open");
	}
	public void close()
	{
		System.out.println("SoundCard close");
	}
}
/*
class MainBoard
{
	public void run()
	{
		System.out.println("mainboard run");
	}
	public void useNetCard(NetCard c)
	{
		c.open();
		c.close();
	}
}

class NetCard
{
	public void open()
	{
		System.out.println("netcard open");
	}
	public void close()
	{
		System.out.println("netcard close");
	}
}
*/

class DuoTaiDemo5 
{
	public static void main(String[] args) 
	{
		MainBoard mb = new MainBoard();
		mb.run();
		mb.usePCI(null);
		mb.usePCI(new NetCard());
		mb.usePCI(new SoundCard());
		
	}
}

posted @ 2014-05-29 17:34 博客园杀手阅读(233) 评论(0) 收藏举报

刷新页面返回顶部

爱生活，爱代码

程序改变世界，心态改变人生

Java面向对象继承（下）

公告

爱生活，爱代码

程序改变世界，心态改变人生

Java面向对象 继承（下）

公告

Java面向对象继承（下）