JAVA的类，对象 继承 接口的认识与实践

1. 类

    类是广泛的概念，表示一个有共同性质的群体，而对象指的是具体的一个实实在在的东西。例如，“人”

是一个类，它可以表示地球上所有的人；而“张三”、“李四”、“爱因斯坦”等则是一个个的对象，或

者说它们是“人”这个类的一个个实例。在 Java 中，我们可以定义类，然后创建类的对象。

class Human{
private String name;
public String getName(){
return name;
}
public void setName(String value){
this.name = value;
}
//......
}

创建一个对象：
Human ahuman = new Human();

java虚拟机将会在内存中创建一个 Human 对象，并将这个对象的引用赋给 ahuman

变量。这里有两步，首先是创建 Human 对象，然后把创建的对象的引用赋给ahuman 变量。

类是对象的模板，对象是类的实例，必须先有类之后而后才可以有对象。在定义的时候应该先把类定义出来。如果要进行类的定义，那么一定要使用class关键字，后面跟上类的名称，而类的名称要求首字母大写。类是对象的模板，对象是类的实例，必须先有类之后而后才可以有对象。在定义的时候应该先把类定义出来。如果要进行类的定义，那么一定要使用class关键字，后面跟上类的名称，而类的名称要求首字母大写。

2.  继承

       通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类，被继承的类称 为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。但Java不支持多重继 承，即一个类从多个超类派生的能力。

2. this和super的用法？ 
◇ super 
　　java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。Super 的使用有三种情况： 
　　1）访问父类被隐藏的成员变量，如： super.variable; 

         2）调用父类中被重写的方法，如： super.Method([paramlist]);  

       3）调用父类的构造函数，如：super.Method([paramlist]);  

this与this()用来引用对象自身的成员。 
This 的使用有三种情况： 
　　1）访问自身对象被隐藏的成员变量，如： this.variable; 

        2）调用自身对象中被重写的方法，如：this.Method([paramlist]);  

        3）调用自身的构造函数，如：this ([paramlist]);

继承中的访问控制符？ 

什么是覆盖？ 
答：我们把子类拥有与父类相同成员的情况称为覆盖(override)。 
访问控制符要使用与父类相同或比父类权限更大的控制符。 
覆盖父类成员的目的在于通过在子类中重新定义扩展父类功能。

 实例成员， 类成员 

 
　　用static 关键字可以声明类变量和类方法，其格式如下： 

如果在声明时不用static 关键字修饰，则声明为实例变量和实例方法。 
　　1） 实例变量和类变量 
　　每个对象的实例变量都分配内存，通过该对象来访问这些实例变量，不同的实例变量是不同的。 
　　类变量仅在生成第一个对象时分配内存，所有实例对象共享同一个类变量，每个实例对象对类变量的改变都会影响到其它的实例对象。类变量可通过类名直接访问，无需先生成一个实例对象，也可以通过实例对象访问类变量。 

　　2） 实例方法和类方法 
　　实例方法可以对当前对象的实例变量进行操作，也可以对类变量进行操作，实例方法由实例对象调用。 
　　但类方法不能访问实例变量，只能访问类变量。类方法可以由类名直接调用，也可由实例对象进行调用。类方法中不能使用this或super关键字。 

单继承与多继承
    JAVA不支持多重继承，单继承使JAVA的继承关系很简单，一个类只能有一个父类，易于管理程序，同时一个类可以实现多个接口，从而克服单继承的缺点。

3. JAVA中的接口 

            Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。               

例如：

public interface Actionlistener{

public abstract void actionPerformed(ActionEvent event);

}

     上面代码里,仅且只有一个方法，只有实现了这个接口(重写这个接口中的唯一一个方法)，你才有资格去事件监听器列表里注册(参数为Actionlistener类型)，当事件源变动时，自动调用这个唯一的actionPerformed方法。

实现接口格式：

[修饰符] class 类名[extends 父类名] [implements 接口A,接口B,···]

{

类成员变量和成员方法；

为接口A中的所有方法编写方法体，实现接口A；

为接口B中的所有方法编写方法体，实现接口B;

}

例子： AreaInterface.java

package jiekou;

abstract Shape()

{

void area(){};

}

public interface AreaInterface{

double pai=Math.PI;

double area();

}

上面的JAVA接口定于程序里只定义了一个空的方法double area();和一个常数。

程序：Rectangle.java

package iekou;

public class Rectangle extends shape implements AreaInterface{

double x,y;

public Rectangle(double a,double b){

x=a;

y=b;

}

public double area()                  //实现接口中的抽象方法，求长方形面积

{

return x * y;

}

public String toString()

{

return "长方形：x="+x+";y="+y+"\t"

area=+area();

}

}

上面这个程序 继承并实现了接口 AreaInterface里面的抽象方法 area();

另外一个程序 ：Circle.java

package jiekou;

public class Circle extends Shape implements AreaInterface{

double r;

public Circle(double x){

r=x;

}

//实现接口中的抽象方法，求圆面积

public double area(){

return pai * r * r;

}

public String toString(){

return "圆：r="+r+"\tarea="+area();

}

}

上面这个程序 同样继承并实现了接口 AreaInterface里面的抽象方法 area(); 可以求出园的面积。

对于一个带有接口定于的类，它只向外面暴露了接口 ，通过接口来调用不同的程序模块，这样符合“内紧外松”的编程原则。就好像电脑主板上的各种插槽一样。IDE,AGP ,PCI USB 主板生产商只是定义了插槽的尺寸大小和引脚的数目，至于是什么商家，生产的板卡，只要符合接口规范就可以插到电脑主板上工作，板卡的内部电路原理，主板不用管。

比如下面的程序。

Shape S1 = new Rectangel();      //向上转型

S1.area();    //调用 求矩形面积的方法

Shape S1 = new Circle();      
S1.area();    //调用 求圆面积的方法  ？？
上面接口的编程的思想在于：矩形类和圆形类通过继承（实现）接口完成面积的计算，而不是直接在类的定于中实现。这样在向上转型时可以统一用接口来调用面积的计算方法。不管什么多边形的面积。只要它是继承于Shape的并实现了area()接口。我们可以统一采用相同的方法来计算。

这样在主程序中可以面向抽象编程。把求面积的程序和计算面积的公式分开编程，实现“解藕”。

-----------------------------------------------------------另一个例子---------------------------------------------------------------

接口的作用就是把使用接口的人和实现接口的人分开，实现接口的人不必要关心谁去使用，而使用接口的人也不用关心谁实现的接口，由接口将他们联系在一起。以上像一段绕口令，那么通过下面的几段程序解释： 
1、以生产和使用一台计算机为例，首先，我们定义了一个显卡的接口，他里面有显示功能和获取显卡名称的功能： 
interface VidioCard 
{ 
void display(); 
String getName(); 
} 
2、显卡的生产者来了，他必须实现接口中定义的所有方法，也可以自己增添若干方法： 
class HaolongVidio implements VidioCard 
{ 


String name="Haolong's vidiocard"; 


void setName(String name){ 
this.name=name; 
} 


public void display(){ 
System.out.println("The Haolong's vidiocard is running!!"); 
} 


public String getName(){ 
return name; 
} 
}; 
显卡制造商生产出了显卡，并且通过setName方法贴上了自己的商标，而通过getName方法可以让使用者知道这块显卡的制造商。 
3、现在显卡已经生产出来了，但是我们还需要一块主板，把生产出来的显卡插到主板上才能够使用，那么我们去买主板： 
class MainBorad 
{ 
String cpuname; 
VidioCard vc; 
void setCPU(String cpuname){ 
this.cpuname=cpuname; 
} 


void setVidioCard(VidioCard vc){ 
this.vc=vc; 
} 


void run(){ 
System.out.println("wudi-mainbord!"); 
System.out.println(vc.getName()); 
vc.display(); 
System.out.println("mainbord is running successful!"); 
} 
}; 
这是主板厂商生产的主板，这也就是我们所说的接口的使用者，在他生产主板的时候并不知道用户使用的是哪块显卡（程序中这样理解：Mainborad这个类只知道接口VidioCard中有哪些方法，但是并不知道接口的实现类HaolongVidio是怎么去实现接口的，也就是生产主板的厂商并没有必要考虑显卡是哪个厂商的，他要做的只是根据接口把显卡插槽做好，接口里没有实现的方法相当于插槽），但是他留出来了显卡的插槽（插槽就是接口），也就是他不关心谁实现的接口，但是他可以使用接口，预留出显卡的插槽让用户去选购显卡。 
4、现在我们用户开始组装计算机了： 
public class ChengDuActor 
{ 
public static void main(String [] args){ 


HaolongVidio hv=new HaolongVidio();//买了一块HaolongVidio显卡 
MainBorad mb=new MainBorad();//买了一块主板 


mb.setCPU("Intel");//买的是Inter主板 
mb.setVidioCard(hv);//把HaolongVidio插到主板上（通过主板上setVidio方法） 


//System.out.println(hv.getName()); 
mb.run();//开电脑运行 
System.out.println("success"); 
} 
}; 
以上看出接口的作用就是大力实现了java的开源性，使软件开发过程优化，接口重要的特征是实现了多样性，能够很好地解决C++中遗留的多继承中出现的问题。

注意： 上面两个程序使用接口的方法不同：

程序1 是通过向上转型 Shape类的对象来调用计算面积的方法。根据转型时的对象不同。Shape对象自动选择不同的算法来求面积。一个通用的命令 shape1.area()。

程序2 是在主板类里面声明一个接口实例。一般接口不能实例化，这里的显卡接口 

VidioCard vc;  是当作 MB里的变量申明使用的。当main() 中设置了不同的显卡类型，就如同给主板插上不同的显卡一样。

不同的显卡就按它们各自不同的方法开始工作。