Java：面向对象（继承，方法的重写（overide），super，object类及object类中方法的重写，父子类代码块执行顺序）

继承：

　　1.继承是对某一匹类的抽象，从而实现对现实世界更好的建模。

　　2.提高代码的复用性。

　　3.extends（扩展），子类是父类的扩展。

　　4.子类继承父类可以得到父类的全部属性和方法。（除了父类的构造方法）。

　　5.java中只有单继承，没有像c++这种的多继承。多继承就是为了实现代码的复用性，但引入了复杂性，使系统之间的关系造成混乱。

　　6.java中的多继承，可以通过接口来实现。

　　7.如果定义一个类时，没有调用extends，则默认定义的父类是：Java.lang.Object。

　　8.不同的的叫法：超类，父类，基类，子类，派生类。

继承:

代表了一种is-a关系。如果说A是B，也就可以说A继承了B。

父类(SuperClass):更加通用。
* 可以子类中共有的特性和功能保存到父类中
* 优点:提高了代码的复用性。

public class Teacher {
    private String name;
    private int age;
    private int wrokOfYear;
 
    public Teacher(String name, int age, int wrokOfYear) {
        // super();
        this.name = name;
        this.age = age;
        this.wrokOfYear = wrokOfYear;
    }
 
    public Teacher() {
        // super();
    }
 
    // getter方法：取值
    public String getName() {
        return name;
    }
 
    // setter方法:赋值
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public int getWrokOfYear() {
        return wrokOfYear;
    }
 
    public void setWrokOfYear(int wrokOfYear) {
        this.wrokOfYear = wrokOfYear;
    }
 
    /**
     * 自我介绍
     */
    public void intro() {
        System.out.println("同学们好,我是" + name + ",今年" + age + "岁,已经工作了" + wrokOfYear + "年");
    }
 
    /**
     * 授课
     */
    public void giveLession() {
        System.out.println("知识点讲解....");
        System.out.println("知识点总结....");
    }
 
}

子类:更加具体
* 在java中使用extends关键字实现继承。
* 一旦两个两个类建立了继承关系，子类就可以拥有父类非私有的属性和方法。
* 子类无法继承父类的构造方法，但可以通过super关键字进行调用。
* 语法 [修饰符] class 子类 extends 父类{
*
* }

方法的重写（override）：一般发生在子类和父类之间

　　1.既可以继承父类的东西又可以灵活的扩充。

　　2.其实就是在子类中重新把父类的同名方法重新写一个进行覆盖。

　　3.重写方法必须和被重写方法有相同的方法名称，参数列表，返回值。

　　4.重写方法不能使用比被重写方法更严格的访问权限。

　　5.子类的修饰符范围>=父类的修饰符范围。

重写（override）和重载（overload）的区别：

* 1.重写一般发生在父子之间，重载一般在同一个类中。
* 2.重写要求方法名，返回值类型，参数列表必须与父类相同，并且修饰符范围大于等于父类方法的修饰符范围。
* 重载方法名相同，参数列表不同，与返回值类型及修饰符无关。
* 3.作用不同。
* 重载主要是为了提供一种同名方法不同参数的能力（可以让一个类用于多个同名的方法）
* 重写主要是为了结合多态使用，提高程序扩展性和可维护性。
*
* 注意:一旦子类重写了父类中的方法，创建子类实例后，调用子类重写后的方法。
*
* @Override:重写的注解，标注当前方法为重写父类的方法，必须满足重写的规则。
*/

super：

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

　　super和this其实都是隐式参数，super指当前父类，this指当前。

public class JavaTeacher extends Teacher{
    public JavaTeacher(){
 
    }
    public JavaTeacher(String name,int age,int workOfYear){
        super(name,age,workOfYear);//调用父类的构造方法
    }
 
    //方法的重写(覆写)
    public void giveLession() {
        System.out.println("打开eclipse.....");
//        System.out.println("知识点讲解.....");
//        System.out.println("知识点总结.....");
        super.giveLession();//使用super调用父类的方法。
    }
}

public class Test {
    public static void main(String[] args) {
        JavaTeacher javaTeacher = new JavaTeacher("zhangsan",30,6);
        javaTeacher.intro();
        javaTeacher.giveLession();
        System.out.println("************************************");
        DBTeacher dbTeacher = new DBTeacher("lisi",33,9);
        dbTeacher.intro();
        dbTeacher.giveLession();
    }
}

public class DBTeacher extends Teacher{
    public DBTeacher(){
 
    }
    public DBTeacher(String name,int age,int workOfYear){
        super(name,age,workOfYear);//调用父类的构造方法
    }
 
    public void giveLession() {
        System.out.println("打开oracle.....");
        super.giveLession();//调用父类的方法
    }
}

super调用父类中带参数的构造方法同时调用自身的属性进行赋值：

public TestCar(String bland,String size,int price,String color){
        super(bland,size,price);
        this.color=color;
    }

任何类的构造函数中，若是构造函数的第一行代码没有显式的调用super(...);那么Java默认都会调用super();作为父类的初始化函数。 所以你这里的super();加不加都无所谓。

public class AtWill {
     public static void main(String[] args) {
            Cat c = new Cat();            //---------------(1)
            System.out.println("-------------------");
            Cat c1 = new Cat("花花",4);   //----------------(2)
        }
    private String color;
    private int foot;
 
    public AtWill(){
        System.out.println("我是父类无参数构造器");
    }
 
    public AtWill(String color,int foot){
        System.out.println("我是父类有参数构造器");
        this.color = color;
        this.foot  = foot;
    }
}
class Cat extends AtWill{
 
    public Cat(){
           // super();                //---------------可以省略，没有super也自动调用父类无参构造
        System.out.println("我是子类无参数构造器");
    }
 
    public Cat(String color,int foot){
        //super(color,foot);         //---------------(3)
             //  super();             //---------------可以省略，调用的父类无参构造
        System.out.println("我是子类有参数构造器");
    }
}
/**
 *  我是父类无参数构造器
    我是子类无参数构造器
-------------------
    我是父类无参数构造器
    我是子类有参数构造器
*/

*java.lang.Object类:所有类的基类
*一个类如果没有显式使用extends继承其他类，这个类继承了Object类，在任何类的对象中使用Object中的方法
*public class Student{
*}
*public class Student extends Object{
*}
*常用的方法:
* getClass() 返回此 Object 的运行时类。主要用于反射机制。
* toString() 返回该对象的字符串表示。如果使用System.out.println(stu);默认调用stu.toString()
* cn.zzsxt.oop6.Student@26ffd553==》
* cn.zzsxt.oop6.Student(包名.类名)+@+16进制表示的hashcode码
* toString()方法经常在子类中重写。
*
*/

public class Student {
    String name;
    int age;
    public Student(){
 
    }
 
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
 
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
 
    public static void main(String[] args) {
        Student stu = new Student("张三",);
//        Student stu2 = new Student();
//        String str = stu.toString();
//        String str2 = stu2.toString();
//        System.out.println(str);
//        System.out.println(str2);
        System.out.println(stu);//默认调用对象的toString();
        System.out.println(stu.toString());
    }
}

重写object中equals方法：

public class Student {
    String name;
    int age;
    public Student(){
 
    }
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    /**
     * 重写Object中equals方法
     */
    @Override
    public boolean equals(Object obj) {
        Student stu = (Student)obj;　　//强转？
        if(name.equals(stu.name)&&age==stu.age){
            return true;
        }else{
            return false;
        }
    }
 
}

/**
 * ==和equals的区别
 * ==在比较内容时分为以下两种情况:
 * 1.使用==比较基本数据类型，做的值的比较,值相同返回true，否则返回false
 * 2.使用==比较引用类型，比较不是内容是否相同，而是两个对象的引用(地址)是否相同，
 *         如果指向相同的地址返回true，否则返回false。
 * equals():比较内容是否相同。
 * Object中的equals方法本质比较引用(==),如果需要按照内容进行比较是否相同，就需要重新Object中equals方法。
 */
public class TestEquals {
    public static void main(String[] args) {
        Student stu = new Student("zhangsan",);
        Student stu2 = new Student("zhangsan",);
        System.out.println(stu==stu2);//比较stu和stu2是否指向相同的地址。
        System.out.println(stu.equals(stu2));//
    }
}

父类和子类中代码的执行顺序
* 静态代码块在使用类时执行。
* 普通代码块在创建对象时执行。
* 父类的静态代码块>子类静态代码块>父类的代码块>父类的构造方法>子类的代码块>子类的构造方法
* 在创建子类时，先调用父类的构造方法先创建父类的实例，在创建子类的实例。

public class Child extends Parent{
    {
        System.out.println("Child....代码块1");
    }
    static{
        System.out.println("Child...static1....");
    }
    public Child(){
        super();
        System.out.println("Child()....");
    }
    {
        System.out.println("Child....代码块2");
    }
    static{
        System.out.println("Child...static2....");
    }
 
    public static void main(String[] args) {
        Child child = new Child();
    }
}

public class Parent {
    {
        System.out.println("Parent....代码块");
    }
    static{
        System.out.println("Parent...static1.....");
    }
 
    public Parent(){
        System.out.println("Parent().....");
    }
 
    {
        System.out.println("Parent....代码块2");
    }
    static{
        System.out.println("Parent...static2.....");
    }
 
}