java类抽象类 接口的

/*
 继承  
 01  提高代码的复用性 
 02  类与类之间产生了关系    多态 的由来、
 03 java支持单继承 不支持多继承 原因当出现多个类中有相同方法时， 子类不确定调用的是哪一
    但是java支持多层继承。在多层继承中，父类定义都是共性成员。  所体现的内容：  
1，父类是不断向上抽取而来的。   
2，既然父类体现的共性内容，那么在使用一个继承体系时，  
只需要查阅最顶层父类即可了解该体系的基本功能。(查阅API技巧之一)  
3，只要建立最子类的对象即可对该继承体系进行应用。
 04 子父类的出现，子类有一个父类引用super，可以获取到父类中非私有的成员。如同子类中也有一个份一样。
  覆盖（复写）override对于成员函数，当子父类中出现了一模一样的函数时，会出现一个覆盖操作。  
  在运行时，会运行子类中的方法。
  覆盖注意： 
     1，子类覆盖父类方法，必须权限大于等于父类。
2，静态覆盖静态。 
3，覆盖只发生在函数即(方法)上。
05 super关键字:代表的父类应用。super的应用和this的使用完全一样。子类的实例化过程：
子类中所有的构造函数回去访问父类中的空参数构造函数。那是因为 每一个子类构造函数中的第一行都有一个句隐式super()语句。
原理：子类继承父类，获取到了父类中的成员，所以子类必须要先明确父类是如何对这些成员进行初始化的。
如何父类中没有了空参数构造函数，需要在子类的构造函数通过super,或者this语句指定要访问的构造函数




final 关键字 
1，final可以修饰类，方法，变量。 
2，final修饰类不可以被继承，但是可以继承其他类。 
3，final修饰的方法不可以被覆盖，但可以覆盖父类方法。 
4，final修饰的变量包括成员变量，类变量，局部变量，这些变量只能赋值一次。  
5，内部类在局部时，只可以访问被final修饰的局部变量。  通常规范中，被final修饰的变量是一个常量，常量名称所有字母大写。 








抽象类：  
分析事物时，发现了共性内容，就出现向上抽取。 会有这样一种特殊情况，就是功能声明相同，但功能主体不同。
那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。  那么该方法就是一个抽象方法。
抽象方法的表现形式：abstract 返回值类型 函数名称(参数列表);  抽象方法一定要存放在抽象类中。
 特点：  
 01 抽象类不能用new进行实例化。  想要创建对象，必须通过子类复写父类中所有的抽象方法后，该子类才可以创建对象。
 
 02抽象类定义时，和一般类一样，都是在描述事物，只不过抽象类可以存放抽象方法，不可以建立对象。
 
 03抽象方法的出现可以强迫子类去做某些事




接口  
简单的理解成抽象类的特殊表现形式，当抽象类的方法全都是抽象的，那么这时就用接口来表示。
 特点： 
 01 接口是对外暴露的规则。 
 02 接口是功能的扩展。  
 03 接口的出现降低了耦合性。  
 04 在java中，多继承的机制被java通过另一种形式来体现，就是多现实。
 05 在java中，一类可以继承一个类的同时，实现多个接口。
 06接口中通常的定义的内容： 
      1，全局常量。 public static final 
 2，公有的抽象方法。 public abstract


 类与类之间是继承关系。
 类与接口之间是实现关系。
 接口与接口之间是继承关系，而且，接口之间存在多继承
 
public abstract void show();
*/
 interface  Dome5 
 { 
public  static final int NUM=12;
public abstract  void show();
 }
class Dome6  implements  Dome5
{   //实现接口中的方法2014/3/19
public  void show()
{
   System.out.println("DOEN");
}
} 












abstract  class  Dome3
{
 abstract void Sleep();
}


class   Dome4  extends Dome3
{
  void Sleep()
{
     System.out.println("困了睡了"); 
  }

}


//--------------------------------
class  Final extends Dome
{
  void show()
{
      System.out.println("我是s带有final的子类方法"); 
    }
}


class  Dome
{


  //子类实例化的时候默认调用父类的无参数的构造函数
Dome()
{
System.out.println(" 我是父类的构造函数");
}
Dome(int s)
{
 System.out.println(s);
}
void show()
    {
      System.out.println("我是父类"); 
     }
}
// Doem1 继承了  Dome 
class Dome1  extends Dome  
{ 
//先调用父类的构造函数在调用自己构造函数
 Dome1 ()
{  
//子类的构造函数显示调用父类的带参数的构造函数
  super(1);
System.out.println(" 我是子类的构造函数");
}
//void show()
//{
//System.out.println("我是子类 覆盖了父类的方法");
//}


}
class  inherit
{
public static void main(String[] args) 
{
 //Dome D=new Dome();
 //D.show();

//  Dome1 D=new Dome1();
//子类方法覆盖了父类的方法
// D.show();
// Dome d=new Dome();
//Final F=new Final();
//F.show();
Dome6 D=new Dome6();
 
}
}