java基础6

packagecom.edu_01;

public class Student {

   //私有化成员变量

   private String name;

   private int age;

   //set/get方法

   public voidsetName(String name){

      this.name = name;

   }

   public String getName(){

      return name;

   }

   public void setAge(int age){

      this.age = age;

   }

   public int getAge(){

      return age;

   }

   //有参数+无参数的构造

   public Student(){}

   public Student(String name,int age){

      this.name = name;

      this.age = age;

   }

   //吃饭和睡觉的方法

   public void eat(){

      System.out.println("学生喜欢吃米饭");

   }

   public void sleep(){

      System.out.println("学生喜欢趴着睡");

   }

}

packagecom.edu_01;

public class Teacher {

      //私有化成员变量

      private String name;

      private int age;

      //set/get方法

      public voidsetName(String name){

        this.name = name;

      }

      public StringgetName(){

        return name;

      }

      public void setAge(int age){

        this.age = age;

      }

      public int getAge(){

        return age;

      }

      //有参数+无参数的构造

      publicTeacher(){}

      publicTeacher(String name,int age){

        this.name = name;

        this.age = age;

      }

      //吃饭和睡觉的方法

      public void eat(){

        System.out.println("老师喜欢吃饺子");

      }

      public void sleep(){

        System.out.println("老师喜欢站着睡");

      }

}

packagecom.edu_02;

继承的好处：

      A:提高了代码的复用性

        多个类相同的成员可以放到同一个类中

      B:提高了代码的维护性

        如果功能的代码需要修改，修改一处即可

      C:让类与类之间产生了关系，是多态的前提

   方法重写(子类的方法名，参数和父类完全一样，将父类方法覆盖)：

   1.必须存在继承关系

   2.父类的方法满足不了你的需求，此时你就需要重写父类的方法，实现自己想要实现的功能*

public class Person {

   //私有化成员变量

   private String name;

   private int age;

   //set/get方法

   public voidsetName(String name){

      this.name = name;

   }

   public String getName(){

      return name;

   }

   public void setAge(int age){

      this.age = age;

   }

   public int getAge(){

      return age;

   }

   //有参数和无参数的构造

   public Person(){}

   public Person(String name,int age){

      this.name = name;

      this.age = age;

   }

   //吃饭和睡觉的方法

   public void eat(){

      System.out.println("民以食为天");

   }

  

   public void sleep(){

      System.out.println("睡觉也是个大事情");

   }

}

packagecom.edu_02;

public class Student extends Person{

  //如果父类的方法不满足子类的需求，子类可以写一个一摸一样的方法在自己的类体中，这样就实现了方法重写

   public void eat(){

      System.out.println("学生喜欢吃米饭");

   }

}

packagecom.edu_02;

 

public class Teacher extends Person{

   //老师喜欢躺着睡，需要重写父类的sleep()方法

   public void sleep(){

      System.out.println("老师喜欢躺着睡");

   }

}

packagecom.edu_02;

public class Test {

   public static voidmain(String[] args) {

      //创建一个学生对象

      Student s = newStudent();

      s.eat();//子类继承了父类的eat()方法和sleep()方法

      s.sleep();   

      System.out.println("------------------");

      //创建一个老师对象

      Teacher t = newTeacher();

      t.eat();

      t.sleep();

   }

}

packagecom.edu_03;

* 1.3

   继承的特点：（代码演示）

      A:Java只支持单继承，不支持多继承。

      B:Java支持多层(重)继承(继承体系)。

   什么时候使用继承呢?

      继承中类之间体现的是：”is a”的关系。

      采用假设法。

        举例：水果，香蕉

        举例：水杯，水果 (不能采用继承。)

        举例：动物，狗

   java中有一个基类，这个类是我们java中所有类的父类，所有类都直接或者间接的继承自在这个类

   ，这个是Object类

classGrandFather{}

class Father extendsGrandFather{}//java不支持多继承，但支持多重继承

class Mother{}

//创建一个儿子类

//class Son extendsFather,Mother{}//java中只支持单继承

class Son extends Father{}

public classExtendsDemo {

}

packagecom.edu_03;

  需求：

      请在show方法中输出40，30，20，10

 class Fu {

   public int num = 10;

   public int num4 = 50;

}

class Zi extends Fu {

   public int num2 = 20;

   public int num = 30; 

   public void show() {

      int num = 40;

      //请问这里面代码怎么写？？？

      System.out.println(num);//输出40

      System.out.println(this.num);//this代表的是本类的一个对象，谁调用我，我指代谁

      System.out.println(num2);

      System.out.println(super.num);//super可以理解为父类的一个对象

      System.out.println(num4);

   }

}

public classExtendsDemo2 {

   public static voidmain(String[] args) {

      //创建Zi类的对象

      Zi z = new Zi();

      z.show();

   }

}

packagecom.edu_03;

/**

 *    怎么去访问父亲的成员呢?

      java就提供了一个关键字：super

   super:

      super代表父类存储空间的标识(可以理解为父类对象)

   this和super的使用区别?

      A:成员变量

        this.成员变量本类的成员变量

        super.成员变量父类的成员变量

      B:成员方法

        this.成员方法()  本类的成员方法

        super.成员方法()父类的成员方法 

*/

class Fu1{

   //创建一个成员变量

   public int num = 20;

   //成员方法

   public void show(){

      System.out.println("这个是父类的show方法");

   }

}

 

class Zi1 extends Fu1{

   //创建两个成员变量

   public int num = 10;

   public int num2 = 20;

   //创建两个成员方法

   public void method(){

      System.out.println("zi的method()");

   }

   public voidfunction(){

      //字啊这里调用method()

      //this.method();//调用本类的method方法

      //super.show();

      System.out.println("zi的function()");

   }

   public void show(){

      int num = 40;

      System.out.println(num);

      System.out.println(num2);

      System.out.println(this.num);

      System.out.println(super.num);

   }

}

 

public classExtendsDemo3 {

   public static voidmain(String[] args) {

      //创建一个zi1的对象

      Zi1 z = new Zi1();

      z.function();

      z.show();

   }

}

packagecom.edu_03;

/**

 * 1.5

   继承间的成员方法关系：

      A:方法名不同，非常简单

      B:方法名相同

        首先在子类中找

        然后在父类中找

        如果还是没有就报错。(不考虑父亲的父亲…)

*/class Fu2{

   public void show(){

      System.out.println("fu2中的show方法");

   }

   public void method(){

      System.out.println("fu2的method方法");

   }

  

   private void function(){

      System.out.println("fu2的function方法");

   }

}

class Zi2 extends Fu2{

   public void show(){

      System.out.println("zi2中的show方法");

   }

  

   public void sleep(){

      System.out.println("睡觉的方法");

   } 

}

public classExtendsDemo4 {

   public static voidmain(String[] args) {

      //创建zi2的对象

      Zi2 z = new Zi2();

      z.sleep();

      z.show();

      z.method();

      //z.fuction();//子类无法继承父类中私有的方法

   }

}

packagecom.edu_04;

public class Animal {

   //成员变量

   private String type;

   private String name;

   private int age;

   //set/get方法

   public voidsetType(String type){

      this.type = type;

   }

   public String getType(){

      return type;

   }

  

   public voidsetName(String name){

      this.name = name;

   }

   public String getName(){

      return name;

   }

   public void setAge(int age){

      this.age = age;

   }

   public int getAge(){

      return age;

   }

   //有参数和无参数构造

   public Animal(){

      System.out.println("Animal的无参数的构造");

   }

   public Animal(Stringtype,String name,int age){

      System.out.println("Animal的有参数的构造");

      this.type = type;

      this.name = name;

      this.age = age;

   }

  

   public void eat(){

      System.out.println("动物喜欢吃粮食");

} 

}

packagecom.edu_04;

public class Dog extends Animal{

   //给dog创建有参数和无参数的构造方法

   //在我们类中的每一个构造方法中的第一行，都会默认存在一个super(),这个就是用来访问父类的构造用的

   public Dog(){

      //super();//注意：这个super()必须输现在第一行，如果出现在下面，就会造成父类数据的重复初始化

      //super(type, name, age);//此时当父类中只有有参构造，没有无参构造的时候，无法在此处访问父类的有参构造初始化父类数据

      System.out.println("dog的无参数的构造");

   }

   public Dog(String type,Stringname,int age){

      //super();

      super(type,name, age);

      System.out.println("dog类的有参数的构造");

      setAge(age);

      setName(name);

      setType(type);

   }

}

packagecom.edu_04;

/**

 * 1.7

   继承间构造方法的关系：

      子类中所有的构造方法默认都会访问父类中空参数的构造方法(super())

   为什么呢?

      因为子类会继承父类中的数据，可能还会使用父类的数据。

      所以，子类初始化之前，一定要先完成父类数据的初始化。

      每个子类的构造方法的第一行，有一条默认的语句:

        super();

      注意：仅仅是完成数据的初始化，创建对象目前必须用new申请空间。

   假如父类没有无参构造方法,该怎么办呢?

      A:调用父类的其他构造方法。带参构造。

        怎么访问呢?

           super(...)

   注意：

      super(…)或者this(….)必须出现在第一条语句上。

      因为如果可以放后面的话，就会对父类的数据进程多次初始化。所以，只能放在第一条语句上。

   建议：

      永远给出无参构造方法。

*/

public class Test {

   public static voidmain(String[] args) {

      //创建一个dog对象

/*    Dog d = new Dog();

      d.setAge(10);

      d.setName("大黄狗");

      d.setType("金毛");

      d.eat();

      System.out.println(d.getAge()+"  "+d.getName()+"  "+d.getType());*/

      System.out.println("------------------------");

      //Dog d2 = new Dog();//子类是无法继承父类的构造方法的

      System.out.println("---------------------");

      //调用dog类的无参数的构造方法

      //Dog d = new Dog();

      //在我们创建子类对象的时候，会默认访问父类的构造方法，此时这个构造方法并不是创建一个

      //父类的对象，仅仅是用来初始化父类的数据用的，为什么我们在这里需要初始化父类的数据呢

      //因为我们子类在后面有可能会使用我这个父类中的数据

     

      //调用dog类的有参数的构造

      Dog d = new Dog("藏獒", "bob", 2);

     

   }

}

packagecom.edu_05;

public class Animal {

   private String type;

   private int age;

   private String name;

  

   public Animal(){}

   public Animal(Stringname,String type,int age){

      this.name = name;

      this.type = type;

      this.age = age;

   }

   public voidsetType(String type){

      this.type = type;

   }

   public String getType(){

      return type;

   }

   public voidsetName(String name){

      this.name = name;

   }

   public String getName(){

      return name;

   }

  

   public void setAge(int age){

      this.age  =age;

   }

   public int getAge(){

      return age;

   }

   //吃饭的方法

   public void eat(){

      System.out.println("动物喜欢吃粮食");

   }

}

packagecom.edu_05;

 

public class Cat extends Animal{

   public Cat(){}

   public Cat(Stringname,String type,int age){

      setAge(age);

      setName(name);

      setType(type);

   }

   //猫喜欢吃鱼

/* public void eat(){

      System.out.println("猫咪喜欢吃鱼");

   }

*/

}

packagecom.edu_05;

public class Dog extends Animal{

   //有参数和无参数的构造方法

   public Dog(){}

   public Dog(Stringname,String type,int age){

      setAge(age);

      setName(name);

      setType(type);

   }

   //狗喜欢吃肉

   public void eat(){

      System.out.println("狗喜欢吃肉");

   }

}

packagecom.edu_05;

public class Test {

   public static voidmain(String[] args) {

      //创建对象

      Dog d = new Dog();

      d.eat();

      System.out.println("------------");

      Cat c = new Cat("bob", "波斯猫", 2);

      c.eat();

      System.out.println(c.getAge()+"  "+c.getName()+"  "+c.getType());

   }

 

}

packagecom.edu_06;

public class Apple extends Fruit{

   //有参和无参构造

   public Apple(){}

   public Apple(Stringtype,String color){

      setColor(color);

      setType(type);

   }

}

packagecom.edu_06;

public class Fruit {

   private String type;

   private String color;

  

   public Fruit(){}

   public Fruit(Stringtype,String color){}

 

   public voidsetType(String type){

      this.type = type;

   }

   public String getType(){

      return type;

   }

  

   public voidsetColor(String color){

      this.color = color;

   }

   public String getColor(){

      return color;

   }

  

   public void show(){

      System.out.println(type+"  "+color+"  ");

   }

}

packagecom.edu_06;

public class Test {

   public static voidmain(String[] args) {

      //创建Apple对象

      Apple a = new Apple();

      a.show();

      System.out.println("-------------");

      Apple a2 = new Apple("红富士", "红色");

      a2.show();

      System.out.println(a2.getColor()+"  "+a2.getType());

     

   }

}

packagecom.edu_07;

* 二：final关键字

   在实际开发的时候，有些方法的内容一旦写定后，就不允许被改动。

   即时是子类，也不允许。那么该怎么解决这个问题呢?

      java为了解决这样的问题就提供了一个关键字：final

   final:

      最终的意思。它可以修饰类,方法,变量。

   特点：

      修饰方法，方法不能被重写。

      修饰类，类不能被继承。

      修饰变量，变量的值不能再改动。其实这个时候变量已经变成了常量。

   常量：

      A:字面值常量

        'a',12,"hello"

      B:自定义常量

        就是把变量用final修饰。

        定义一个常量。

 

        final 数据类型变量名;

class Fu{//一个类如果被final修饰过后，就不能被继承

   //写一个被final修饰的方法

   public final void eat(){

      System.out.println("fu的eat()");

   }

}

 

class Zi extends Fu{

   //尝试重写父类中的eat(),子类复发重写父类中被final修饰过的方法

   /*public void eat(){

   }*/

   final int NUM = 20;

   //自定义一个常量，这个常量有多个单词组成

   final int MAX_AGE = 30;

   final String URL = "WWW.BAIDU.COM";

}

 

public class FinalDemo{

   public static voidmain(String[] args) {

      //创建Zi的对象，访问他的被final修饰过的成员变量num

      Zi z = new Zi();

      //尝试改变被final修饰过的成员变量num

      //z.num = 30;//被final修饰过的变量不能被更改，此时他已经成了常量

      System.out.println(z.NUM);

     

   }

}

packagecom.edu_08;

* 三：多态

   3.1

   多态：同一个对象,在不同时刻表现出来的不同状态。

   举例：

      A:猫

        猫是猫

        猫是动物

      B:水

        水(液态)

        冰(固态)

        水蒸气(气态)

   多态的前提：

      A:有继承关系  

      B:有方法重写（不是必要条件，但是只有有了方法重写多态才有意义）  

      C:有父类引用指向子类对象

 

        Fu f = new Fu();

 

        左边：Fu类型的引用

        右边：Fu类型的对象

 

        Zi z = new Zi();

 

        Fu f = new Zi();

   3.2

   成员访问特点

      A:成员变量

        编译看左边,运行看左边

      B:构造方法

        子类构造默认访问父类的无参构造

      C:成员方法（重点理解）

        编译看左边,运行看右边

        为什么变量和方法不一样呢?

           方法重写。

      D:静态成员方法

        编译看左边,运行看左边

        因为静态的内容是和类相关的，与对象无关。

class Fu{

   //创建一个成员变量

   int num = 20;

   public void show(){

      System.out.println("fu的show（）");

   }

   public static void method(){

      System.out.println("fu的method（）");

   }

}

class Zi extends Fu{//1.存在继承关系

   int num = 30;

   public void show(){//2.存在方法重写

      System.out.println("zi的show");

   }

   public static void method(){

      System.out.println("zi的method（）");

   }

}

public classDuoTaiDemo {

   public static voidmain(String[] args) {

      //3.父类引用指向子类对象

      Fu f = new Zi();

      System.out.println(f.num);

      //多态的情况下：成员变量的访问特点是，编译看左边，运行看左边

      System.out.println("---------------------------");

      f.show();

      //多态的情况下：成员方法的访问特点：编译看左边，运行看右边

      System.out.println("---------------------------");

      f.method();

      //多态情况下静态成员方法的访问特点：编译看左边，运行看左边

}

}

packagecom.edu_09;

public class Animal {

   private String type;

   private int age;

   private String name;

  

   public Animal(){}

   public Animal(Stringname,String type,int age){

      this.name = name;

      this.type = type;

      this.age = age;

   }

   public voidsetName(String name){

      this.name = name;

   }

   public String getName(){

      return name;

   }

   public void setAge(int age){

      this.age  = age;

   }

   public intgetAage(){

      return age;

   }

   public voidsetType(String type){

      this.type = type;

   }

   public String getType(){

      return type;

   }

   //吃的方法

   public void eat(){

      System.out.println("动物喜欢吃饭");

   }

}

packagecom.edu_09;

 

public class Cat extends Animal{

 

   public Cat(){}

   public Cat(Stringname,String type,int age){

      setAge(age);

      setName(name);

      setType(type);

   }

   //猫喜欢池鱼

   public void eat(){

      System.out.println("猫喜欢吃鱼");

   }

   //猫有一个特有的功能，猫会捉老鼠

   public voidcatchMouce(){

      System.out.println("猫有一个捉老鼠的特有技能");

   }

}

packagecom.edu_09;

public class Dog extends Animal{

   public Dog(){}

   public Dog(String name,intage,String type){

      setAge(age);

      setName(name);

      setType(type);

   }

   //狗有一个特有技能会看门

   public voidlookDoor(){

      System.out.println("狗会看门");

   }

}

packagecom.edu_09;

* 练习：（猫狗案例演示）

   如何使用子类特有功能

      A:创建子类对象

      B:把父类引用转为子类对象

   向上转型

      从子到父

      父类引用指向子类对象

   向下转型

      从父到子

      父类引用转为子类对象

*/

public class Test {

   public static voidmain(String[] args) {

      //使用多态的方式创建一个Cat对象

      Animal a = new Cat();

      a.eat();

      //a.catchMouce();

      //需求：就像在这里调用猫中特有功能，捉老鼠

      //方式1：创建Cat对象，使用Cat类型去接受

      Cat c = new Cat();

      c.catchMouce();

      System.out.println("------------");

      //方式2:向下转型，将父类引用转换成子类对象

      Cat c2 = (Cat)a;

      c2.catchMouce();

      System.out.println("--------------");

      //将a这个引用转换成Dog对象？？？

      //Dog d = (Dog)a;

      //java.lang.ClassCastException:类型转换异常

      //d.eat();

      //d.lookDoor();

     

      System.out.println("----------------");

      Animal a2 = new Dog();

      a2.eat();

      //a2.lookDoor();

      Dog d = (Dog)a2;

      d.lookDoor();

   }

}

packagecom.edu_10;

* 4.1

   抽象类特点:

      A:抽象类和抽象方法必须用abstract关键字修饰

      B:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

      C:抽象类不能实例化

        那么，如果实例化并使用呢?

        按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

      D:抽象类的子类

        要么是抽象类

        要么重写抽象类中的所有抽象方法

   抽象类的作用：

      强制要求子类必须要重写某些方法。

 *

 */

abstract class Animal{

   //抽象类中不一定有抽象方法

   public void sleep(){

      System.out.println("动物都喜欢睡大觉");

   }

   //定义一个抽象方法,1.使用abstract进行修饰  2，抽象方法没有方法体，因为抽象根本就不是一个具体的方法

   //3.如果一个类中有抽象方法，这个类一定是抽象类  4.抽象方法没有具体的实现，需要让他的具体子类做具体的实现

   public abstract void eat();

}

class Dog extends Animal{

   public void eat() {

      System.out.println("狗喜欢吃肉");

   }

}

class Cat extends Animal{

   public void eat() {

      System.out.println("猫喜欢吃鱼");

   }

}

//定义一个抽象类继承Animal这个类,如果一个抽象类继承另一个抽象类，不需要重写父类中的抽象方法

//abstract classPerson extends Animal{}

 

public classAbstractDemo {

   public static voidmain(String[] args) {

      //创建狗的对象

      Dog d = new Dog();

      d.eat();

      System.out.println("----------");

      //使用多态的方式创建对象，并调用eat（）方法

      //此时使用的多态的方式是：抽象类多态

      /**

       * 多态的分类：

       *1.普通类多态

       *2.抽象类多态

       *       前两种全部是父类引用指向子类对象

       *3.接口多态

       *       父接口引用指向接口实现类对象

       */

      Animal a = new Dog();

      a.eat();

   }

}

packagecom.edu_10;

* 4.2

   抽象类--特点--成员特点--案例

   类的组成：

      成员变量：

      构造方法：

      成员方法：

   抽象类的成员：

      成员变量：可以是变量，也可以是常量。

      构造方法：有构造方法

        不能实例化,构造方法有什么用呢?

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

      成员方法：既可以是抽象的，也可以是非抽象的。

abstract class Animal2{

   //成员变量：可以是变量，也可以是常量。

   int num = 10;//变量

   final int num2 = 20;

  

   //抽象类有构造方法吗？？？

   //既然我们刚才说过我们的抽象类不能被实例化，为什么抽象类还可以具有构造方法呢？

   //这里的构造方法是为了初始化我们的父类数据，并不是用来做一个对象的实例化的

   public Animal2(){}

  

   //成员方法：可以是普通成员方法，也可以是抽象方法，

   //一个类如果具有抽象方法这个类一定是抽象类

}

public classAbstractDemo2 {

}

packagecom.edu_11;

public abstract class Animal {

   private String type;

   private String name;

  

   public Animal(){}

   public Animal(Stringtype,String name){

      this.name = name;

      this.type= type;

   }

  

   public voidsetType(String type){

      this.type = type;

   }

   public String getType(){

      return type;

   }

   public voidsetName(String name){

      this.name = name;

   }

   public String getName(){

      return name;

   }

  

   //吃饭的抽象方法

   public abstract void eat();

}

packagecom.edu_11;

public class Cat extends Animal{

   public Cat(){}

   public Cat(Stringname,String type){

      setName(name);

      setType(type);

   }

   public void eat() {

      System.out.println("猫爱吃鱼");

   } 

   //猫会捉老鼠

   public void catchMouse(){

      System.out.println("猫会逮老鼠");

   }

}

packagecom.edu_11;

 

public class Dog extends Animal{

  

   public Dog(){}

   public Dog(Stringname,String type){

      setName(name);

      setType(type);

   }

   public void eat() {

      System.out.println("狗爱吃肉");

   }

   //狗特有的看门方法

   public voidlookDoor(){

      System.out.println("狗会看门");

   }

 

}

packagecom.edu_11;

public class Test {

   public static voidmain(String[] args) {

      //利用多态的方式创建一个狗的对象

      Animal a = new Dog();

      a.eat();

      Dog d = (Dog)a;

      d.lookDoor();

     

      System.out.println("--------------");

      //使用猫的有参构造创建一个对象

      Animal a2 = new Cat("bob", "加菲猫");

      a2.eat();

      System.out.println(a2.getName()+"  "+a2.getType());    

   }

}

packagecom.edu_12;

/**

 *    接口的特点：

      A:定义接口要用关键字interface表示

        格式：interface接口名 {}

      B:类实现接口用implements表示

        格式：class 类名 implements 接口名 {}

      C:接口不能实例化

        那么，接口如何实例化呢?

        按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态,接口引用指向实现类对象

      D:接口的实现类

        要么是抽象类

        要么重写接口中的所有抽象方法

       

   5.3  

   接口的成员特点：

      A:成员变量

        只能是常量。

        默认修饰符：publicstatic final

      B:构造方法

        没有构造方法

      C:成员方法

        只能是抽象方法。

        默认修饰符：publicabstract

 *

 */

//定义一个接口

interface inter{

   //接口中可以定义那些东西呢？

   //1.在接口中定义一些变量

   //接口中所有的变量都会默认被final修饰，所以我们的接口中说白了只能定义常量，不能定义变量

   //接口中的成员变量不仅被final默认修饰，还被static默认修饰

   //我们接口中的变量全部是静态常量

   public static final int num = 20;

  

   //2.接口中能否定义一个构造方法呢？？

   //接口中不能存在构造方法

   //public inter(){}   

   //3.接口中可以存在普通的成员方法吗？

   //接口中的所有方法都是抽象方法

   public abstract void show();

}

//定义一个类实现这个接口

class InterImplimplements inter{

   @Override

   public void show() {

      System.out.println("来自接口中扩展的抽象方法");

   } 

}

//定义一个抽象类，让这个抽象类实现接口,此时这个抽象类不需要重写接口中的抽象方法

abstract classAbstractInterImpl implements inter{}

public classInterfaceDemo {

   public static voidmain(String[] args) {

      //利用多态的方式将接口进行实例化

      inter i = newInterImpl();

      //试图更改成员变量的值

      //i.num = 30;//接口中所有的变量都会默认被final修饰，所以我们的接口中说白了只能定义常量，不能定义变量

      //System.out.println(i.num);

      System.out.println(inter.num);

   }

}

packagecom.edu_12;

/**

 * 5.4  

   类与类：

      继承关系。只能单继承，可以多层(重)继承。

   类与接口：

      实现关系。可以单实现，也可以多实现。

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

   接口与接口：

      继承关系。可以单继承，也可以多继承。

interface Inter1{}

interface Inter2{}

interface Inter3 extendsInter2,Inter1{}

//创建一个类实现一个接口,或者多个接口

classInterImpl3 implements Inter1,Inter2{}

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

 

classInterImpl4 extends InterImpl3 implements Inter3{}

public classInterfaceDemo2 {

}

packagecom.edu_13;

public abstract class Animal {

   //私有化成员变量

   private String name;

   private int age;

  

   //有参无参构造

   public Animal(){}

   public Animal(String name,int age){

      this.name = name;

      this.age = age;

   } 

   public voidsetName(String name){

      this.name = name;

   }

   public String getName(){

      return name;

   }

  

   public void setAge(int age){

      this.age = age;

   }

   public int getAge(){

      return age;

   }

  

   //吃的抽象方法

   public abstract void eat();

}

packagecom.edu_13;

 

public class Cat extends Animal{

  

   public Cat(){}

   public Cat(String name,int age){

      setAge(age);

      setName(name);

   }

   public void eat() {

      System.out.println("猫爱吃鱼");

   }

   //所有的猫都会逮老鼠

   public voidcatchMouse(){

      System.out.println("猫会逮老鼠");

   }

}

packagecom.edu_13;

public class Dog extends Animal{

   //有参无参构造

   public Dog(){}

   public Dog(String name,int age){

      setAge(age);

      setName(name);

   }

   public void eat() {

      System.out.println("狗吃骨头");

   }

   //所有的狗都会看门

   public voidlookDoor(){

      System.out.println("狗会看家");

   }

}

packagecom.edu_13;

 

public class JumpCat extends Cat implements Inter{

  

   public JumpCat(){}

   public JumpCat(String name,int age){

      setAge(age);

      setName(name);

   }

   public void jump() {

      System.out.println("经过多年的刻苦训练，终于练成了跳高技能");

   }

}

packagecom.edu_13;

 

public class JumpDog extends Dog implements Inter{

  

   public JumpDog(){}

   public JumpDog(String name,int age){

      setAge(age);

      setName(name);

   }

   public void jump() {

      System.out.println("这条狗不简单呐，居然会跳高");

   }

}

packagecom.edu_13;

public class Test {

   public static voidmain(String[] args) {

      //多态的方式创建一个普通狗

      Animal a = new Dog();

      a.eat();

      Dog d = (Dog)a;

      d.lookDoor();

      System.out.println("------------------");

      //创建一个跳高狗

      JumpDog jd = newJumpDog();

      jd.eat();

      jd.lookDoor();

      jd.jump();

   }

 

}