JavaSE重要知识点回顾（二）——基础语法篇

JavaSE重要知识点回顾（二）——基础语法篇

书接上回：https://editor.csdn.net/md/?articleId=109223893
上一篇文章我们回顾到了方法，今天我们继续我们的回顾之路。

面向对象

java是面向对象的编程语言，如何正确的理解面向对象是java程序员一生的追求。没有多年的工作经验是无法全面理解何为面向对象的。

1.类
1）对象共有特征的一种抽象，类里面有属性（成员变量）和动作（方法）。
2）类通过实例化变成对象，对象通过抽象化变成类。
——在你没有找到对象之前，你脑海中会想：我想要一个肤白貌美的，长发，温柔的女朋友。你并没有真正的女朋友，你想象的女朋友就是一个 类 ，她没有具体指向谁，仅仅只是肤白貌美，长发温柔。

2.对象
——在你真正找到一个对象后，此时的对象才是真的对象，她有真实的姓名，有自己的脾气，有自己的人生过往，此时你的对象就具体了，明确了。
1）类通过实例化来创建一个对象，此时在JVM的堆内存中会开辟一个空间来存储此对象。
2）在堆内存中的对象都有自己的成员变量，这些成员变量有一个新的名字，实例变量。
3）实例化对象的语法是： 类名 引用 = new 类名（）；
4）引用其实就是局部变量，在方法体中定义。
5）引用这个局部变量中保存的是对象在堆内存中的内存地址。

3.构造方法
1）每一个类都必须至少有一个无参的构造方法。
2）构造方法的作用：创建对象，对实例化对象进行初始化。
3）构造方法的方法名与类名相同。
4）如果没有书写构造方法，系统会默认给此类一个无参的构造方法。
5）如果手动写了一个有参的构造方法，那么系统就不会再帮你写一个无参的构造方法，必须手动写一个***无参***的构造方法。
6）构造方法可以重载，没有返回值。
7）在构造方法中，如果没有手动对实例化对象进行初始化，那么系统会对实例对象的实例变量赋默认值，不用写赋值语句。

public class Text02 {
    public static void main(String[] args){
        Animal dog = new Animal();//这段代码会调用Animal的无参构造
        System.out.println(dog.age);//0
        System.out.println(dog.name);//null

    }
}
class Animal{
    public int age;
    public String name;
    //无参构造
    public Animal(){
        //此方法会对age 和 name 赋默认值
    }
}

4.面向对象三大特征（封装、继承、多态）

1.封装
1）封装就是把某些信息隐藏在程序的内部，不允许外部程序直接访问，而是通过类提供的方法来对隐藏的信息进行修改和读取。
2）封装的好处：封装是为了代码安全，方便操作。为程序提供了唯一的一个入口。改setter，读getter，能够为属性的修改和读取增加合法的判断语句。
3）封装的实现：第一步私有化实例变量，第二步提供setter和getter方法。

public class Text02 {
    public static void main(String[] args){
        Animal dog = new Animal();//这段代码会调用Animal的无参构造
        System.out.println(dog.getAge());//0
        System.out.println(dog.getName());//null

        dog.setName("Tom");
        dog.setAge(5);

        System.out.println(dog.getAge());//5
        System.out.println(dog.getName());//Tom

    }
}
class Animal{
    private int age;
    private String name;
    //无参构造
    public Animal(){
        //此方法会对age 和 name 赋默认值
    }

    //可以重载以下方法对属性进行合理的判断
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

4.static和this关键字
在说继承之前，我们先来回顾一下static和this关键字。

1）static关键字
a. 没有static关键字修饰的方法和变量就是实例的，对象级别的。每一个对象都有一个，必须通过 引用. 才能调用

b. 有static修饰的就是静态的，是类级别的。静态变量在类加载的时候就已经初始化了。静态变量存储在方法区中。有static修饰的方法必须使用 类名.方法名 调用。

c. static{} 静态代码块。静态代码块是在类加载的时候执行的，按照从上倒下的顺序执行，这是sun公司给程序员提供的一个特殊时刻。

2）this关键字
a.this是一个关键字，大多数情况下可以省略，代表一个引用。

b.this关键字保存在堆的对象中，她保存他所在对象的内存地址，指向自身，谁去调用实例方法，this就代表谁。

c.this可以在构造、实例方法中使用，但是不能在静态方法中使用。this和static水火不容，不能一起出现。

d.this关键字大多数情况下可以省略，但是在用于区分局部变量和实例变量时不能省略。

e.this()只能用在构造方法的第一行，作用是调用此类的其他构造方法。

5.继承

继承是面向对象三大特征之一。把一些类相同的属性特征抽出来构建一个新的类，这个新的类就是父类（基类/超类）。那么继承这个父类的类就具有了父类的特征。

1）继承的作用：子类继承父类，代码得到复用，这是继承的基本作用。最重要的作用是：有了继承才有后面的覆盖和多态。

2）继承的特征：子类可以继承父类除构造方法、private修饰的方法和属性外的所有特征。

3）java的继承只支持单继承，一个父类可以有多个子类，但一个子类只能有一个直接父类。不支持多继承，但支持间接继承。

4）java类如果不继承其他类，，则默认继承Object类，Object类是老祖宗类，java对象与生俱来就具有Object类的所有特征。

6）继承也存在缺点，修改父类，子类也会发生变化，提高了程序的耦合度。

6.方法的覆盖
方法覆盖就是子类从父类继承的方法无法满足子类的业务要求，此时就需要方法覆盖。

方法覆盖的条件：
1）条件一：两个类之间必须有继承关系。
2）覆盖的方法，方法名，返回类型，参数列表必须相同
3）访问权限不能更低，可以更高。
4）重写之后的方法不能比之前抛出更多的异常，可以更少。

7.重写equals和toString方法
equals和toString都是Object类中的方法，toString是把引用转换成字符串，一搬情况下都要重写toString方法。

/**
 * 未重写toString方法
 */
public class Test0 {
    public static void main(String[] args){
        Test0 t = new Test0();
        System.out.println(t.toString());//com.butcher.Test0@723279cf
    }
}

/**
 * 重写toString方法
 */
public class Test0 {
    public static void main(String[] args){
        Test0 t = new Test0();
        System.out.println(t.toString());//重写toString
    }

    @Override
    public String toString() {
        return "重写toString";
    }
}

equals是比较两个引用是否相等的方法，比较的是内容。= = 比较的是内存地址，但是= =在比较基本数据类型时，只要基本数据类型的内容相等，结果可以返回true。

/**
 * 未重写equals方法
 */
public class Test0 {
    public static void main(String[] args){
        Animal a = new Animal(1,"tom","北京");
        Animal b = new Animal(1,"tom","北京");
        System.out.println(a.equals(b));//false
    }

}

重写Animal中的equals方法

public boolean equals(Animal obj) {
        if (this == obj){
            return true;
        }
        if (obj instanceof Animal && !(obj==null) && this.name == obj.name && this.age == obj.age && this.advice == obj.advice ){
            return true;
        }

        return false;
    }

/**
 * 重写equals方法
 */
public class Test0 {
    public static void main(String[] args){
        Animal a = new Animal(1,"tom","北京");
        Animal b = new Animal(1,"tom","北京");
        System.out.println(a.equals(b));//true

    }
}

8.多态
多态让程序有了很好的扩展性，多种形态，多种状态，运行期叫动态绑定，比如Animal a = new Cat(); a.eat()在编译阶段是Animal的eat（），所以会区Animal中找eat（）方法，找到后编译通过。但是在真正执行的时候会调用堆内存中实际对象的eat（）方法。

多态的形式：向上转型和向下转型。向上转型是子类转向父类（子类对象指向父类型的引用）。向下转型是父类转向子类（父类型对象指向子类型引用，向需要强制类型转换），互相转换的两个类必须是继承关系，否则会出现类型转换异常。

向下转型：子类型的引用指向父类型的对象，需要强转

 Bird b =(Bird)new Animal();

向上转型：父类型的引用指向子类型的对象；

Animal animal = new Bird();

下期再见。