抽象和接口：

Ø 抽象和接口：

 

 

public abstract  class Emp {

private String name ; 

String id ;

double salary;

Emp (){}

Emp(String name,String id ,double salary){

this.name =name ;

this.id =id ;

this.salary =salary;

}

public abstract void sleep();  //如果父类有抽象方法 ，子类一定要重写父类的方法 

public abstract void Zheng();

public void setName (String name){

this . name = name ;

}

   public String name (){

    return  name ;

   }

   

   

}

public class Manager extends Emp {

Manager (){}

Manager (String name ,String id ,double salary){

 super (name,id,salary);  //参数是父类的，所以用super　父类的空间标识

}

        public void sleep(){

        System.out.println("睡觉");

        }

 

public void Zheng() {

            System.out.println("挣钱"); 

} 

}

 

public class Employ {

         public static void main(String[] args) {

Emp e =new Manager("元哥吉祥","951852753",123);

e.sleep();

e.Zheng();

 

System.out.println(e.name());

System.out.println(e.id);

System.out.println(e.salary);

    

}

}

 

 

 

抽象-- 具体

抽象-- 是看不见 ，摸不到的, 看不懂的,

 

抽象的关键字 :abstract 

 

     可以修饰类，方法，被修饰的类，叫抽象类， 被修饰的方法叫抽象方法 

Abstract 

       修饰方法：

   　　　　　Public  abstract void eat (); // 不能有方法体，

 

       修饰类：

            Abstract class 类名

 

      注意：

          1.类里面有抽象方法，类必须是抽象的。

          2. 但是 ， 抽象类里面不一定全都是抽象方法

  

      抽象类不能被实例化，就是不能被new  ，我们只能使用它的子类对象

      虽然不能被实例化，但是依然有构造方法，作用是，当子类创建对象时候，父类可以初始化数据

 

子类的要求：

 

   1， 要么是抽象的，

   2. 要么覆盖分类中所有的抽象方法、

 

 

 

抽象类的成员特点：

  A,  成员变量： 即可以是变量，也可以是常量

 B   . 构造方法 ： 有

              用于子类访问父类数据的初始化

C . 成员方法： 即可以是抽象的，也可以是非抽象的。

 

 B.  抽象类的成员方法特性:

   A. 抽象方法。  强制要求子类做的事情

  B . 非抽象方法。 子类继承的事情，提高代码的复用性

          

 

 

接口：

 

 接口的特点：

 1. 接口内部有抽象的方法，默认的有abstract 修饰 

  

 2 接口就不能被实例化，不能new  不能创建对象

 

 3；类是可以实现接口的，实现了接口的那个类， 是这和接口的子类(接口是这个类的干爹)

 

4： 子类是可以实例化的。

 

 

成员的特点：

  1. 成员变量只能是常量，final 修饰， static 修饰

   

  2. 没有构造方法，因为子类有，默认的构造或者继承了其他类的构造

 

 3. 成员方法，只能是抽象的，不可以有非抽象的方法，默认 abstract

 

 

 

public abstract  class Animal {

 //狗儿在这个接口里面学习技能

    interface Jie{  //写接口

     public  void Tiao();        //interface 默认抽象方法

    }

    public abstract void eat();

    public abstract void sleep ();

    public abstract void Jiao();

    

    private String name ;

             int  age ;

       Animal (){}

       Animal (String name ,int age ){

       this. name = name ;

       this. age =age ;

       }

       

       public void setName (String name){

       this.name = name ;

       }

       public String getName (){

       return name ;

       }

 

}

 

 

 

public class Dog extends Animal {

  Dog (){}

  Dog(String name,int age){

  super (name ,age);

  }

public void Jiao() {

System.out.println("笨口会乱叫");

}

 

 

public void eat() {

System.out.println("笨狗能吃肉");

}

 

 

public void sleep() {

System.out.println("笨狗能睡觉");

}

}

 

import jiekou.Animal.Jie;

                                      //实现接口 和子类对接

public class MaXiTuanD extends Dog implements Jie{

MaXiTuanD (){}

MaXiTuanD (String name ,int age){

super (name,age);

}

   public void Tiao() {

System.out.println("狗会说人话"); 

}

   public void eat(){

   System.out.println("马戏团的狗边吃边说人话");

   }

   public void sleep(){

    System.out.println("马戏团的狗站着睡觉");

   }

   public void Jiao (){

   System.out.println("马戏团的狗从来不叫");

   }

   

 

}

 

public class AnimalTest {

 public static void main(String[] args) {

 Animal a  = new Dog ();

 a.eat();

 a.Jiao();

 a.sleep();

 

 Animal an = new MaXiTuanD(); //父类引用 子类的对象

 an.eat();

 an.Jiao();

 an.sleep();

 

 MaXiTuanD m =(MaXiTuanD) an;  //父类就想拿到子类的独有方法，那么就强转

 m.Tiao();

}

 

}