尚学堂--面向对象2

1、继承中的构造方法

• 子类的构造过程必须调用父类的构造方法
• 子类可以在自己的构造方法中使用 super(argument_list)调用父类的构造方法
  • 　　使用 this(argment_list) 调用本类的另外的构造方法
  • 　　如果调用super，必须写在子类构造方法的第一行
• 如果子类的构造方法中没有显示的调用父类构造方法，则系统默认调用父类无参数的构造方法
• 如果子类构造方法中既没有显式调用父类构造方法，而父类中又没有无参的构造方法，则编译出错

class SuperClass {
    private int n;

    SuperClass() {
        System.out.println("SuperClass");
    }

    SuperClass(int n) {
        System.out.println("SuperClass(" + n + ")");//先输出传入的参数
        this.n = n;//再把参数赋值给成员变量
    }
}

class SubClass extends SuperClass {
    private int n;

    SubClass() {
        super(300);
        System.out.println("SubClass");
    }

    SubClass(int n) {
        System.out.println("SubClass(" + n + ")");
        this.n = n;
    }
}

public class Test {
    public static void main(String[] args) {
        SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass(400);
    }
}

 这个不太好分析：

class Person {
    private String name;
    private String location;

    Person(String name) {
        this.name = name;
        location = "beijing";
    }

    Person(String name, String location) {
        this.name = name;
        this.location = location;
    }

    public String info(){
        return "name  = " + name + "location = " + location;        
    }
}

class Student extends Person {
    private String school;

    Student(String name, String school) {
        this(name, "beijing",school);//调用的是Student(String n, String l, String school){}方法
    }

    Student(String n, String l, String school) {
        super(n,l);
        this.school = school;
    }
    public String info() {
        return super.info() + "school" + school;
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person("A");
        Person p2 = new Person("B","shanghai");
        Student s1 = new Student("C", "S1");
        Student s2 = new Student("C", "shanghai", "S2");

        System.out.println(p1.info());
        System.out.println(p2.info());
        System.out.println(s1.info());
        System.out.println(s2.info());
    }
}

 2、Object类

• Object类是所有Java类的根基类
• 如果在类的声明中未使用extends关键字指明其父类则默认为Object类
• 在java.lang这个包下（特例：Java中只有使用java.lang中的方法可以不导入java.lang这个包，其他的必须导入包）

toString方法：

　　Object类中定义有public String toString()方法，其返回值是String类型，描述当前对象的相关信息

　　再进行String与其他类型数据的连接操作时（如：System.out.println("info" + Person)），将自动调用该对象类的toString()方法

　　可以根据需要在用户自定义类型中重写toString()方法

equals方法：

　　

3、对象转型（对象转型调用的是属性，多态调用的是方法）

一个父类的引用类型变量可以“指向”子类的对象

一个父类的引用不可以访问其子类对象新增加的成员（属性和方法）

可以使用  引用 变量 instanceof 类名 来判断该引用型变量所“指向”的对象是否属于该类或该类的子类

子类的对象可以当作父类的对象来使用称作向上转型（upcasting），反之成为向下转型（downcasting）

对象转型1

//定义一种动物
class Animal {
    public String name;
    Animal(String name) {
        this.name = name;
    }
}
//猫继承了动物
class Cat extends Animal {
    public String eyeColor;
    Cat(String n, String e) {
        super(n);
        eyeColor = e;
    }
}
//狗继承了动物
class Dog extends Animal {
    public String furColor;
    Dog(String n, String f) {
        super(n);
        furColor = f;
    }
}

public class Test {
    public static void main(String[] args) {
        Animal a = new Animal("name");
        Cat c = new Cat("catname", "blue");
        Dog d = new Dog("dogname", "black");

        System.out.println(a instanceof Animal);//true，a是一种Animal
        System.out.println(c instanceof Animal);//true，c是一种Animal
        System.out.println(d instanceof Animal);//true，d是一种Animal
        System.out.println(a instanceof Cat);//false  ，Animal不是一种Cat

        /*
　　　　　Animal类型的a指向子类对象Dog，
　　　　　　 a指向了Dog中Animal的name属性和Dog的furColor属性
　　　　　　 但是a只能访问Dog自身的name属性，不能访问Dog自身的furColor属性

        */
        a = new Dog("bigDog", "yellow");
        System.out.println(a.name);//bigDog
        //System.out.println(a.eyeColor);  errer

        /*
　　　　　　a = new Dog后，a是一种Dog，只是不能访问子类特有的成员
        */
        System.out.println(a instanceof Animal);//true
        System.out.println(a instanceof Dog);//true
        /*
　　　　　　要想访问子类特有的成员，需要强制类型转换
        */
        Dog d1 = (Dog)a;
        System.out.println(d1.furColor);//yellow
    }
}

对象转型2

//定义一种动物
class Animal {
    public String name;
    Animal(String name) {
        this.name = name;
    }
}
//猫继承了动物
class Cat extends Animal {
    public String eyeColor;
    Cat(String n, String e) {
        super(n);
        eyeColor = e;
    }
}
//狗继承了动物
class Dog extends Animal {
    public String furColor;
    Dog(String n, String f) {
        super(n);
        furColor = f;
    }
}

public class Test {
    public static void main(String[] args){
        Test test = new Test();
        Aniaml a = new Animal("name");
        Cat c = new Cat("catname", "blue");
        Dog d = new Dog("dogname", "black");
        test.f(a);
        test.f(c);
        test.f(d);
    }
    /*
    
    
    父类引用指向子类对象,可扩展性比较好（但是还没有达到最好，最好是多态）
    否则需要写三个f()方法f(Animal a)、 f(Cat a) 、f(Dog a)
    才能调用有继承关系的Animal、Cat、Dog
    
    */
    public void f(Animal a) { //父类引用指向子类对象
        if(a instanceof Cat) {
            Cat cat = (Cat) a;
            System.out.println(" " + cat.eyesColor + " eyes");
        }else if(a instanceof Dog) {
            Dog dog = (Dog) d;
            System.out.println(" " + dog.eyesColor + " eyes");
        }
    }
}

 4、动态绑定和多态（可扩展性达到最好）

三个条件：

• 要有继承
• 要有重写
• 父类引用指向子类对象

动态绑定是指“在执行期间（而非编译期间）判断所引用对象的实际类型，根据实际的类型调用其相应的方法”

class Animal {
    private String name;
    Animal(String name) {
        this.name = name;
    }
    public void enjoy(){
        System.out.println("叫声.....");
    }
}

class Cat extends Animal {
    private String eyeColor;
    Cat(String name, String eyeColor) {
        super(name);
        this.eyeColor = eyeColor;
    }
    public void enjoy() {
        System.out.println("猫叫声.....");
    };
}

class Dog extends Animal {
    private String furColor;
    Dog(String name, String furColor) {
        super(name);
        this.furColor = furColor;
    }
     public void enjoy() {
        System.out.println("狗叫声.....");
    };
}

class Lady {
    private String name;
    private Animal pet;
    Lady(String name, Animal pet) {
        this.name = name;
        this.pet = pet;
    }
    public void myPetEnjoy() {
        pet.enjoy();
    }
}

public class Test {
    public static void main(String[] args) {
        Cat c = new Cat("catname", "blue");
        Dog d = new Dog("dogname", "black");

        Lady l1 = new Lady("l1", c);
        Lady l2 = new Lady("l2", d);

        l1.myPetEnjoy();
        l2.myPetEnjoy();
    }
}

程序中有3个enjoy方法，当你调用的时候调的哪一个是根据实际当中的类型来确定，而不是通过引用中的类型来确定（参考对象上面对象转型）

 5、抽象类和方法

用abstract关键字来修饰一个类时，这个类叫做抽象类

用abstract关键字来修饰一个方法时，这个方法叫做抽象方法

含有抽象方法的类必须被声明为抽象类

抽象类必须被继承，抽象方法必须被实现

抽象类不能被实例化

抽象方法只需声明，不需要实现

6、final关键字

final的变量的值不能够被改变

• final的成员变量
• final的局部变量

final的方法不能被重写

final的类不能被继承

7、接口

接口是抽象方法和常量值的定义的集合

从本质上讲，接口是一种特殊的抽象类，这种抽象类只包含常量和方法的定义，而没有变量和方法的实现

接口定义举例：

public interface Runner {
    public static final int id = 1;
    public void start();
    public void run();
    public void stop();
}

 接口特性：

接口可以多重实现

接口中声明的属性默认为public static final的，也只能是public static final的

接口中只能定义抽象方法，而且这些方法默认为public的，也只能是public的

接口可以继承其它的接口，并添加新的属性和抽象方法

多个无关的类可以实现同一接口

一个类可以实现多个无关的接口

与继承关系类似，接口与实现类之间存在多态性

interface Singer {
    public void sing();
    public void sleep();
}

interface Painter {
    public void paint();
    public void eat();
}

class Student implements Singer {//Student继承了Singer
    private String name;
    Student(String name) {
        this.name = name;
    }
    public void study() {
        System.out.println("studying");
    }
    public String getName() {
        return name;
    }
    public void sing() {//实现了sing方法
        System.out.println("student is singing");
    }
    public void sleep() {//实现了sleep方法
        System.out.println("student is sleeping");
    }
}

class Teacher implements Singer, Painter {//Teacher继承了Singer、Painter
    private String name;
    public String getString() {
        return name;
    }
    Teacher(String name) {
        this.name = name;
    }
    public void teach() {
        System.out.println("teaching");
    }
    public void sing() {//Teacher继承了sing方法
        System.out.println("teacher is singing");
    }
    public void sleep() {//Teacher继承了sleep方法
        System.out.println("teacher is sleep");
    }
    public void paint() {//Teacher继承了paint方法
        System.out.println("teacher is paint");
    }
    public void eat() {//Teacher继承了eat方法
        System.out.println("teacher is eat");
    }
}

public class Test {
    public static void main(String[] args) {
        Singer s1 = new Student("le");
        s1.sing();
        s1.sleep();
        Singer s2 = new Teacher("steven");
        s2.sing();
        s2.sleep();
        Painter p1 = (Painter) s2;
        p1.paint();
        p1.eat();
    }
}

结果：
student is singing
student is sleeping
teacher is singing
teacher is sleep
teacher is paint
teacher is eat