java 面向对象基本知识

1.继承

　　使用extends实现继承 只有单继承

　　子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)。

　　 instanceof是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象时，返回true；否则，返回false。

　　

public class Test{
    public static void main(String[] args) {
        Student s = new Student("张三",007,"Java");
        System.out.println(s instanceof Student);
    }
}

2.方法的重写

　　子类通过重写父类的方法，可以用自身的行为替换父类的行为。方法的重写是实现多态的必要条件。

　   方法的重写需要符合下面的三个要点：

       (1).“==”： 方法名、形参列表相同。

       (2).“≤”：返回值类型和声明异常类型，子类小于等于父类。

       (3).“≥”： 访问权限，子类大于等于父类。

class Vehicle { // 交通工具类
    public void run() {
        System.out.println("跑....");
    }
}
class Horse extends Vehicle { // 马也是交通工具
    public void run() { // 重写父类方法
        System.out.println("四蹄翻飞，嘚嘚嘚...");
    }
}

3.==和equals

　　“==”代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。

　　Object类中定义有：public boolean equals(Object obj)方法，提供定义“对象内容相等”的逻辑。

　　Object 的 equals 方法默认就是比较两个对象的hashcode，是同一个对象的引用(内存地址相同)时返回 true 否则返回 false。但是，我们可以根据我们自己的要求重写equals方法。

　　

public boolean equals(Object obj) {
        if(obj == null){ //为空没有比较的必要
            return false;
        }else {
            if(obj instanceof Person) {
                Person c = (Person)obj;
                if(c.id==this.id) {
                    return true;
                }
            }
        }
        return false;
    }

4.super

　　super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

　　若是构造方法的第一行代码没有显式的调用super(...)或者this(...);那么Java默认都会调用super(),含义是调用父类的无参数构造方法。这里的super()可以省略。

5.封装

　　

　　

　　类的属性的处理:

      1. 一般使用private访问权限。

      2.  提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作

　  3. 一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

6.多态　　

　  (1). 多态是方法的多态，不是属性的多态(多态与属性无关)。

      (2). 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

      (3). 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

class Animal {
    public void shout() {
        System.out.println("叫了一声！");
    }
}

class Dog extends Animal {
    public void shout() {
        System.out.println("旺旺旺！");
    }
    public void seeDoor() {
        System.out.println("看门中....");
    }
}
class Cat extends Animal {
    public void shout() {
        System.out.println("喵喵喵喵！");
    }
}

public class TestPolym {
    public static void main(String[] args) {
        Animal a1 = new Cat(); // 向上可以自动转型
        //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
        animalCry(a1);
        Animal a2 = new Dog();
        animalCry(a2);//a2为编译类型，Dog对象才是运行时类型。
         
        //编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
        // 否则通不过编译器的检查。
        Dog dog = (Dog)a2;//向下需要强制类型转换
        dog.seeDoor();
    }
 
    // 有了多态，只需要让增加的这个类继承Animal类就可以了。
    static void animalCry(Animal a) {
        a.shout();
    }
 
    /* 如果没有多态，我们这里需要写很多重载的方法。
     * 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。
    static void animalCry(Dog d) {
        d.shout();
    }
    static void animalCry(Cat c) {
        c.shout();
    }*/
}

7.final关键字

　　(1). 修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。

final  int   MAX_SPEED = 120;

　　(2). 修饰方法：该方法不可被子类重写。但是可以被重载!

final  void  study(){}

　　(3). 修饰类: 修饰的类不能被继承。比如：Math、String等。

final   class  A {}