面向对象03

 1     public static void method(Animal a) {    
 2                 //当作参数的时候用多态最好,因为扩展性强
 3                 //当传入对象是猫或者狗的时候,实际上Animal a = 猫,所以用到多态了
 4         //关键字 instanceof 判断前边的引用是否是后边的数据类型
 5         if (a instanceof Cat) {
 6             Cat c = (Cat)a;
 7             c.eat();
 8             c.catchMouse();
 9         }else if (a instanceof Dog) {
10             Dog d = (Dog)a;
11             d.eat();
12             d.lookHome();
13         }else {
14             a.eat();
15         }
16     }    

 1 abstract class Animal {                        //抽象类
 2     public abstract void eat();                //抽象方法,子类继承抽象类,抽象方法是强制要重写的,和接口一样,不重写,抽象还有什么意义
 3     public Animal() {
 4         System.out.println("父类空参构造");
 5     }
 6 }
 7 class Cat extends Animal {
 8     public Cat() {
 9         super();
10     }
11 
12     @Override
13     public void eat() {
14         // TODO Auto-generated method stub
15         System.out.println("mao ci yu");
16     }
17 }
18 class Demo1_Abstract {
19     public static void main(String[] args) {
20         //Animal a = new Animal();            //错误: Animal是抽象的; 无法实例化
21         Animal a = new Cat();                //父类引用指向子类对象
22         a.eat();
23     }
24 }

 1 abstract class Demo {
 2     int num1 = 10;//变量
 3     final int num2 = 20;//常量
 4 
 5     public Demo(){}//构造方法
 6 
 7     public void print() {//非抽象方法，子类可以直接使用
 8         System.out.println("我是码农");
 9     }
10 
11     public abstract void method();//抽象方法，子类必须实现
12 }
13 
14 class Test extends Demo {
15     public void method() {
16         System.out.println("绝地求生");
17     }
18 }

1 public interface Inter {
2     public static final int num = 10;//这里写不写public static final都会默认加上
3     public abstract void print();//这里写不写public abstract都会默认加上,因为写接口本来就是为了实现的啊,会默认加上abstract
4 }

1 class Demo implements Inter {
2     public Demo() {
3         super();
4     }
5     public void print() {
6         //num = 20;num已经被final修饰了,不能重新赋值
7         System.out.println(num);
8     }
9 }

1 public class Demo2_Interface {
2     public static void main(String[] args) {
3         Demo d = new Demo();
4         d.print();
5         System.out.println(Inter.num);
6     }
7 }

 1 abstract class Animal {
 2     private String name;                
 3     private int age;                    
 4     public Animal() {}                    
 5     public Animal(String name,int age) {
 6         this.name = name;
 7         this.age = age;
 8     }
 9 
10     public void setName(String name) {
11         this.name = name;
12     }
13 
14     public String getName() {            
15         return name;
16     }
17 
18     public void setAge(int age) {        
19         this.age = age;
20     }
21 
22     public int getAge() {                
23         return age;
24     }
25     public abstract void eat();        
26     public abstract void sleep();    
27 }

 1 class Cat extends Animal {
 2     public Cat() {}                    
 3     public Cat(String name,int age) {
 4         super(name,age);
 5     }
 6     public void eat() {
 7         System.out.println("猫吃鱼");
 8     }
 9     public void sleep() {
10         System.out.println("侧着睡");
11     }
12 }

1 interface Jumping {    
2     public void jump();
3 }

1 class JumpCat extends Cat implements Jumping {
2     public JumpCat() {}
3     public JumpCat(String name,int age) {
4         super(name,age);
5     }
6     public void jump() {
7         System.out.println("猫跳高");
8     }
9 }

 1 public class Test1_Animal {
 2     public static void main(String[] args) {
 3         Cat c = new Cat("加菲",8);
 4         c.eat();
 5         c.sleep();
 6         JumpCat jc = new JumpCat("跳高猫",3);
 7         jc.eat();
 8         jc.sleep();
 9         jc.jump();
10     }
11 }