JavaSE Day8

本节内容

1.面向对象思维

2.面向对象的3大特征：继承

3.super关键词

4.方法的重写

5.final关键词

一、面向对象编程：

面向对象编程：

  1.面向对象编程是一种思维方式。

      特点：

              1.先整体，后局部

              2.先抽象，后具体

              3.能做什么，具体做什么

二、面向对象：继承

         为什么要有继承：如果没有继承，那么现在有这么2个程序：一个人Person  、一个学生 Student

package com.xk;
/*
 *作者：吴志龙
 *日期：2018年7月27日  
*/
public class Person {
    
      private String name ;
      private int age ;
      public void setName(String name) {
                this.name = name ;
      }
      public void setAge(int age) {
                this.age = age ;
      }
      public String getName() {
                return this.name ;
      }
      public int getAge(){
                return this.age ;
      }

    

}

package com.xk;
/*
 *作者：吴志龙
 *日期：2018年7月27日  
*/
public class Student {
     private String name ;
     private int age ;
     private String school ;
     public void setName(String name) {
               this.name = name ;
     }
     public void setAge(int age) {
               this.age = age ;
     }
     public void setSchool(String school) {
               this.school = school ;
     }
     public String getName() {
               return this.name ;
     }
     public int getAge(){
               return this.age ;
     }
     public String getSchool() {
               return this.school ;
     }

}

以上两个程序通过代码的比较可以清楚的发现：代码之中存在了重复，而按照之前所学，这种重复是不可能消除的。

在所有的代码之中，最具有重复意义的就是链表类，针对于每一个简单Java类或者是说其他的任何类，都编写一个链表程序，代码量庞大，而且不方便维护。

继承的概念：

   继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

Java中的继承是单继承：一个子类只能有一个直接的父类，但是一个父类可以有多个子类。但是Java中允许多重继承。

Java中继承的语法：

class 子类 extends 父类{

}

子类又被称为派生类； 父类又被称为超类（Super Class）。

 继承的限制：

1一个子类只能够继承一个父类，存在单继承局限。

2在一个子类继承的时候，实际上会继承父类之中的所有操作（属性、方法），但是需要注意的是，对于所有的非私有（no private）操作属于显式继承（可以直接利用对象操作），而所有的私有操作属于隐式继承（间接完成）

3 在继承关系之中，如果要实例化子类对象，会默认先调用父类构造，为父类之中的属性初始化，之后再调用子类构造，为子类之中的属性初始化，即：默认情况下，子类会找到父类之中的无参构造方法。

在任何的情况下，子类都逃不出父类构造的调用，很明显，super调用父类构造，这个语法和this()很相似：super调用父类构造时，一定要放在构造方法的首行上。

super

在Java中使用supeer来引用父类的属性以及方法

在JAVA类中使用super来引用父类的成分，用this来引用当前对象，如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，this指的是当前对象的引用，super是当前对象里面的父对象的引用

方法的重写：

既然现在出现了继承的关系，那么就存在了子类和父类的联系，而在子类之中有可能定义和父类完全相同的方法或属性的名称，这个时候就称为覆写了。

当子类定义了和父类在方法名称、返回值类型、参数类型及个数完全相同的方法的时候，称为方法的覆写。

没有覆写：

class A {
    public void print() {
        System.out.println("Hello World .");
    }
}

class B extends A {
}

public class Test {
    public static void main(String args[]) {
        B b = new B();
        b.print(); // 方法从父类继承而来
    }
}

运行结果

Hello World .

这时实例化的是子类对象，但是在子类中没有print()方法，那么就使用从父类中继承而来的pritn()方法。

实现覆写：

class A {
    public void print() {
        System.out.println("Hello World .");
    }
}

class B extends A {
    public void print() { // 方法名称、参数类型及个数、返回值全相同
        System.out.println("世界，你好！");
    }
}

public class Test {
    public static void main(String args[]) {
        B b = new B();
        b.print(); // 方法从父类继承而来
    }
}

运行结果
世界，你好！

当一个类中的方法被覆写后，如果实例化的是这个子类对象，则调用的方法就是被覆写过的方法。

在进行方法覆写的时候有一点需要注意：被子类所覆写的方法不能拥有比父类更严格的访问控制权限。
如果此时父类之中的方法是default权限，那么子类覆写的时候只能是default或public权限，而如果父类的方法是public，那么子类之中方法的访问权限只能是public。

当一个子类覆写了一个父类方法的时候，子类要想调用父类的被覆写过的方法，要在方法前要加上“super”

一定要记住操作范围：
（1）this.方法()：先从本类查找是否存在指定的方法，如果没有找到，则调用父类操作；
（2）super.方法()：直接由子类调用父类之中的指定方法，不再找子类

final关键词：

  final关键字的基本用法

在Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。下面就从这三个方面来了解一下final关键字的基本用法。

1.修饰类

　　当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。

2.修饰方法

　下面这段话摘自《Java编程思想》第四版第143页：

　　“使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。“

　　因此，如果只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。

　　注：类的private方法会隐式地被指定为final方法。

　3.修饰变量

　　修饰变量是final用得最多的地方，也是本文接下来要重点阐述的内容。首先了解一下final变量的基本语法：

对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。