黑马程序员技术交流社区

标题: java基础-day09 [打印本页]

---

作者: 王哲zhe    时间: 2015-8-16 21:25
标题: java基础-day09
1.多态：对象在不同时刻表现出来的不同状态。
        针对引用类型：
                编译期间状态，
                运行期间状态，
        前提：
                A：要有继承关系
                B：要有方法重写
                C：父类引用或父接口指向子类对象
例题：class Fu{
        public void show(){
                System.out.println("A");
        }
       
      }
        class Zi extends Fu{
                public void show(){
                        System.out.println("B");
                }
        }
        class Test{
                public static void main(String[] args){
                        //多态
                        Fu fu = new Zi();
                }
        }

2.多态的成员特点：方法有重写，变量没有。
        A：成员变量：
                编译看左边，运行看左边
        B：成员方法：
                编译看左边，运行看右边
例题：class Fu{
        int num = 10;
        public void show(){
                System.out.println("A");
        }
       
      }
        class Zi extends Fu{
                int num = 20;
                public void method(){
                        System.out.println("C");
                }
                public void show(){
                        System.out.println("B");
                }
        }
        class Test{
                public static void main(String[] args){
                        //多态
                        Fu fu = new Zi();
                        System.out.println(num);//10
                        fu.show();//B
                        fu.method();//报错，编译时父类没有method方法
                }
        }

3.多台弊端：父类引用不能使用子类特有功能
        关于转换：
                基本数据类型：
                        a.隐式转换（小--->大）    b.强制转换（大--->小）
                引用数据类型：
                        a.向上转型（小--->大）    b.向下转型（大--->小）
例题：class Fu{
        int num = 10;
        public void show(){
                System.out.println("A");
        }
       
      }
        class Zi extends Fu{
                int num = 20;
                public void method(){
                        System.out.println("C");
                }
                public void show(){
                        System.out.println("B");
                }
        }
        class Test{
                public static void main(String[] args){
                        //多态
                        Fu fu = new Zi();//向上转型
                        Zi z = (Zi)fu;//向下转型
                        System.out.println(num);//10
                       
                }
        }

4.异常：java.lang.ClassCastException   类型转换异常
例题：class Animal
{
        public void show(){
                System.out.println();
        }
}

class Cat extends Animal
{
        public void method(){
                System.out.println("cat method");
        }
        public void show(){
                System.out.println("cat show ");
        }
}

class Dog extends Animal
{
        public void show(){
                System.out.println("dog show");
        }
        public void method(){
                System.out.println("dog method");
        }
}

class DuoTaiDemo
{
        public static void main(String[] args){
                Animal a = new Cat();//向上转型
                a.show();

                a = new Dog();//重新赋值
                a.show();

                Dog d = (Dog)a;//向下转型
                d.show();

                Cat c = (Cat)a;//ClassCastExceprion:类型转换异常
                c.show();
        }
}

5.多态的好处： 为了提高代码的复用性
例题：class Animal{
        public void show(){
                System.out.println("Animal show");
        }

        public void eat(){
                System.out.println("Animal eat");
        }
}

class Dog extends Animal{
        public void show(){
                System.out.println("Dog show");
        }

        public void eat(){
                System.out.println("Dog eat 骨头");
        }
}

class Cat extends Animal{
        public void show(){
                System.out.println("Cat show");
        }

        public void eat(){
                System.out.println("Cat eat 鱼");
        }
}

class wolf extends Animal{
        public void show(){
                System.out.println("wolf show");
        }

        public void eat(){
                System.out.println("wolf eat 肉");
        }
}


class AnimalTool{
        private AnimalTool(){}

        public static void printAnimal(Animal a){
                a.eat();
                a.show();
        }
}

class HaoChu{
        public static void main(String[] args){
                Dog d = new Dog();
                AnimalTool.printAnimal(d);
        }
}

6.抽象：abstract class Animal{
                public abstract void eat();
        }
        针对没有方法体的方法，java提供了一种表示形式：抽象方法。
        抽象方法就是没有方法体的方法
        抽象类不能创建对象，不能实例化
        抽象类的由来：从很多对象中中抽取相同的方法声明，定义在一个新的类中，没有方法体的方法被成为抽象方法，存储抽象方法的类就

是抽象类

7.抽象类的特点：
        A：抽象方法和抽象类用关键字 abstract 表示
        B：有抽象方法的类一定是抽象类或接口
                抽象类中一定有抽象方法
        C：抽象类不能被实例化
                如何实例化？通过子类对象实例化
        D：如果一个类继承抽象，那么这个类要么本身也是抽象类，要么子类重写父类的抽象方法

8.在继承中为什么选择父类为抽象类呢？
        强制要求子类必须完成某些功能

9.抽象类的成员特点：
        A：成员变量:既有常量，也可以有变量
        B：构造方法：有构造方法
                不能实例化，要构造方法何用呢？
                        用于子类访问父类数据钱对父类数据进行初始化
        C：成员方法：可以有抽象方法，也可以有非抽象方法，非抽象方法是为了提高代码的复用性。抽象方法是为了强制子类实现某些功能

10.接口：只有抽象方法的抽象类，用interface表示
        把抽象类改写为：
        interface Animal{
                public abstract void eat();
        }
   接口怎么用？必须要有具体的类来实现（implements）
   格式：class 类名 implements 接口名{
               
                }
例题：class Cat implements Animal{
        public void eat(){
                System.out.println("");
        }
        }

11.接口多态：
        Animal a = new Cat();
        a.eat();

12.接口特点：
        A：接口不能被实例化
        B：接口中的方法要么被子类重写，要么子类也是抽象类

13.接口的成员特点：
        成员变量：接口中只有常量，因为接口中的成员变量有默认的修饰符 public static final
                  推荐：永远手动写出修饰符
        构造方法：接口中没有构造方法，接口不需要对数据初始化，因为接口被静态修饰，只有常量，不需要初始化
        成员方法：接口中的方法都是抽象的，接口中的成员方法有默认的修饰符 public abstract  永远手动给出修饰符

14.类与接口的关系：
        实现关系，可以单实现也可以多实现，并且可以在继承一个类的同时实现多个接口
   类与类的关系：
        继承关系，而且只能单继承，但可以多层继承
   类与接口：
        继承关系，可以单继承，也可以多继承

15*****面试常考
A：成员特点：
        抽象类：
                成员变量：可以是变量，也可以是常量
                构造方法：有构造方法
                成员方法：可以是抽象方法也可以是非抽象方法
        接口：
                成员变量：只能是常量  默认修饰符是 public static final
                成员方法：只能是抽象方法  默认修饰符  public abstract
B：关系特点：
        类与类：继承关系，只能单继承，可以多层继承
        类与接口：实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。
        类与接口：继承关系，可以单继承，也可以多继承。
C：设计理念的区别：
        抽象类被继承，这个类中是继承体系的共性内容
                体现：is a 关系
        接口被实现，这个接口中定义的是整个体系的扩展内容
                体现：like a 关系

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2