2013年8月26日、抽象类 | 接口

/*
抽象类：
抽象：笼统，模糊，看不懂！不具体。






特点：
1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。
抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。
3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。
否则，这个子类还是抽象类。




1，抽象类中有构造函数吗？
有，用于给子类对象进行初始化。





2，抽象类可以不定义抽象方法吗？
可以的。 但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。
通常这个类中的方法有方法体，但是却没有内容。


abstract class Demo
{
void show1()
{}



void show2()
{}
}






3，抽象关键字不可以和那些关键字共存?
private 不行
static 不行
final 不行






4，抽象类和一般类的异同点。
相同点：
抽象类和一般类都是用来描述事物的，都在内部定了成员。
不同：
1，一般类有足够的信息描述事物。
  抽象类描述事物的信息有可能不足。
2，一般类中不能定义抽象方法，只能定非抽象方法。
  抽象类中可定义抽象方法，同时也可以定义非抽象方法。
3，一般类可以被实例化。
  抽象类不可以被实例化。








5，抽象类一定是个父类吗？
是的。因为需要子类覆盖其方法后才可以对子类实例化。 








*/


abstract class Demo
{
abstract /*抽象*/ void show();

}


/*


class DemoA extends Demo
{
void show()
{
System.out.println("demoa show");
}
}
class DemoB extends Demo
{
void show()
{
System.out.println("demob show");
}
}
*/
abstract class 犬科
{
abstract void 吼叫();
}


class 狗 extends 犬科
{

void 吼叫()
{
System.out.println("汪汪");
}
}
class 狼 extends 犬科
{
void 吼叫()
{
System.out.println("嗷嗷");
}
}






class AbstractDemo 
{
public static void main(String[] args) 
{
System.out.println("Hello World!");
}

}

-------------------------------------------------------------------------------------------

/*
雇员示例：
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给出需求进行数据建模。






分析：
在这个问题领域中，先找出涉及的对象。
通过名词提炼法。
程序员：
属性：姓名，工号，薪水、
行为：工作。
经理：
属性：姓名，工号，薪水，奖金。
行为：工作。




程序员和经理不存在着直接继承关系，


但是程序员和经理却具有共性内容。
可以进行抽取。因为他们都是公司的雇员 


可以将程序员和经理进行抽取.建立体系.

*/


//描述雇员。


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 Programmer extends Employee
{
Programmer(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println("code...");
}
}


//描述经理。 
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("manage");
}
}












class  AbstractTest
{
public static void main(String[] args) 
{
System.out.println("Hello World!");
}
}




class Person
{
private String name;
private int age;


Person(String name,int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
}
class Student extends Person
{
Student(String name,int age)
{
super(name,age);
}


}
class Worker extends Person
{
Worker(String name,int age)
{
super(name,age);
}

}

————————————————————————————————

/*
abstract class AbsDemo
{
abstract void show1();
abstract void show2();
}


当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
另一种形式定义和表示，就是 接口 interface。
*/


//定义接口使用的关键字不是class，是interface.
/*
对于接口当中常见的成员：而且这些成员都有固定的修饰符。
1，全局常量: public  static final 


2，抽象方法。public abstract 


由此得出结论，接口中的成员都是公共的权限.




*/
interface Demo
{
public static final int NUM = 4;


public abstract void show1();
public abstract void show2();
}
//类与类之间是继承关系，类与接口直接是实现关系。 
/*
接口不可以实例化。


只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。
否则，这个子类就是一个抽象类。


*/




class DemoImpl implements /*实现*/Demo
{
public void show1()
{}


public void show2()
{

}
}




/*
在java中不直接支持多继承，因为会出现调用的不确定性。
所以java将多继承机制进行改良，在java中变成了多实现。


一个类可以实现多个接口。 


*/


interface A
{
public void show();
}


interface Z
{
public int add(int a,int b);
}








class Test implements A,Z//多实现
{

public int add(int a,int b)
{
return a+b+3;
}
/**/
public void show(){}

}










/*
一个类在继承另一个类的同时，还可以实现多个接口。






*/
class Q
{
public void method()
{}
}


abstract class Test2 extends Q implements A,Z
{


}
/*
接口的出现避免了单继承的局限性。


*/




interface CC
{
void show();
}
interface MM
{
void method();
}


interface QQ extends  CC,MM//接口与接口之间是继承关系，而且接口可以多继承。 
{
void function();
}


class WW implements QQ
{
//覆盖3个方法。
public void show(){}
public void method(){}
public void function(){}
}




class InterfaceDemo 
{
public static void main(String[] args) 
{


Test t = new Test();
t.show();


// DemoImpl d = new DemoImpl();
// System.out.println(d.NUM);
// System.out.println(DemoImpl.NUM);
// System.out.println(Demo.NUM);
}
}






/*
抽象类和接口的异同点：


相同点：
都是不断向上抽取而来的。




不同点：
1，抽象类需要被继承，而且只能单继承。
  接口需要被实现，而且可以多实现。 
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
  接口中只能定义抽象方法，必须由子类去实现。 
3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
  接口的实现是 like a 关系，在定义体系额外功能。








犬按功能分：有导盲犬，搜爆犬。




abstract class 犬
{
abstract void 吼叫();
}


//abstract class 导盲
interface 导盲
{
abstract void 导盲();
}




class 导盲犬 extends 犬 implements 导盲
{
public void 吼叫()
{
}
public void 导盲(){}
}






//在不同的问题领域中，有不同的分析方式。
学员：
学习。
抽烟学员








烟民。















*/


class InterfaceDemo 
{
public static void main(String[] args) 
{
System.out.println("Hello World!");
}
}