Java面向对象

面向对象

本质

以类的方式组织代码，以对象的组织（封装）数据。

三大特性

• 封装
• 继承
• 多态

从认识论角度是先有对象后有类。对象，是具体的事物。类，是对对象的抽象。

从代码运行角度考虑是先有类后有对象。类是对象的模板。

创建与初始化对象

• 使用new关键字创建对象

  使用new关键字创建对象的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，一个类即使什么都不写，也会自动生成空构造器。并且构造器有以下两个特点：

1. 必须和类名字相同。
2. 必须没有返回类型，也不能写void。

使用new关键字，本质是在调用构造器。

• 有参构造：一旦定义无参构造就必须显示定义。（类似于方法的重载）根据你new时是否传参来确定调用哪个构造器。
• 构造器一般用来初始化值。
• alt + insert 快捷键创造构造器。

内存分析

简单分为栈、堆、方法区。

1. 栈空间（stack），连续的存储空间，遵循后进先出的原则，用于存放局部变量。
2. 堆空间（heap），不连续的空间，用于存放new出的对象，或者说是类的实例。
3. 方法区（method），方法区在堆空间内，用于存放①类的代码信息；②静态变量和方法；③常量池（字符串常量等，具有共享机制）。

对于这样一段代码：

它的内存分配情况为：

---

1. 封装（信息的隐藏）

1. 属性私有

在类中的属性用private修饰，外部无法调用，要想调用只能用get/set方法。

2. get/set

提供一些可以操作这个属性的方法。

• get 获得这个数据。
• set 给这个数据设置值。
• alt + insert 可以自动生成get/set方法。
• set 可以加一些安全性的判断。

优点

1. 提高程序的安全性，保护数据。
2. 隐藏代码的实现细节。
3. 统一接口。
4. 系统的可维护性增加了。

2. 继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

关键字：extends

形式

public class 子类 extends 父类{}

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有"is a"的关系。

• 子类继承了父类，就会拥有父类的全部方法。
• Ctrl + H可以打开继承树。
• 在Java中，所有的类都默认直接或者间接继承Object。
• Java中类只有单继承，没有多继承！
• 被final修饰后不能被继承。

super

• this 指向当前类，super 指向父类。
• super 必须只能出现在子类的方法或者构造器中。
• 子类的构造器在调用之前先调用父类的无参构造。
• 可以用来调用父类的构造器，必须在子类构造器的第一行。
• super 和 this 不能同时调用构造方法。

方法重写

• 静态方法：方法的调用只和左边定义的数据类型有关。
• 非静态方法：重写。

//假设A继承B，A是B的子类。
A a = new A;
a.test();

//父类的引用指向了子类
B b = new A;//子类重写了父类的方法
b.test();//重写时调用的是B类的方法

需要有继承关系，子类重写父类的方法！

1. 方法名必须相同。
2. 方法体不同。
3. 参数列表必须相同。
4. 修饰符：范围可以扩大但不能缩小：
   public > protected > default > private
5. 抛出的异常：范围可以缩小但不能扩大。
   ClassNotFoundException --> Exception（大）

为什么要重写？

• 父类的功能子类不一定需要，或者不一定满足。

快捷键： Alt + Insert; override;

3.多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多。
如果父类的方法被重写，那么调用时会调用被重写后的方法。

条件

• 有继承关系
• 子类重写父类方法
• 父类引用指向子类对象

//主程序
package oop;

public class Main {
    
    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Student
        //new Person

        //可以指向的引用类型就不确定了：父类的引用指向子类

        //Student 能调用的方法是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        s2.eat();
        s1.eat();
        s2.study();
    }
    
}

package oop;

public class Person {
    public void eat() {
        System.out.println("BIGeat");
    }

    public void study() {
        System.out.println("Study");
    }
}

package oop;

//学生类
public class Student extends Person{

    public void eat() {
        System.out.println("eat");
    }

}

输出结果：

instanceof

判断两个对象是否有继承关系。
编译是否通过看引用类型（左边），结果对错看实际类型（右边）

//Teacher 和 Student 继承 Person
package oop;

public class Main {
    
    public static void main(String[] args) {

        Object object = new Student();
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false

        System.out.println("=============================");

        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//ture
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String); 编译错误

        System.out.println("=============================");

        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher); 编译错误
        //System.out.println(student instanceof String); 编译错误
    }
    
}

注意

1. 父类引用指向子类的对象。
2. 把子类转换为父类，向上转型。（可能会丢失方法）
3. 把父类转换为子类，向下转型，强制转换！
4. 方便方法的调用，减少重复的代码！

static

被static修饰的方法或者属性，可以在同一类中直接调用，也可以直接用类名.XX调用。

package oop;

public class Person {

    {
        System.out.println("匿名代码块");
    }
		
    static {
        System.out.println("静态代码块");
    }

    Person() {
        System.out.println("构造方法");
    }

}

package oop;

public class Main {
    
    public static void main(String[] args) {

        Person person = new Person();

    }
    
}

可以看到，先执行静态代码块，再执行匿名代码块，其次是构造方法。

抽象类

关键字：abstract

在方法前加abstract此方法为抽象方法，只有方法名，没有方法的实现，不能new，只能靠子类去实现它；约束！

抽象类里可以有普通方法，但抽象方法只能在抽象类中。

抽象类的所有方法，继承了它的子类，都必须要实现它的方法。除非子类也是抽象类。

接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法，接口中的方法默认为抽象方法（public abstract），属性默认为常量（pubic static final）

本质：契约

关键字：interface

public interface UserService {
	void run();
}

需要实现类！可以多继承！

关键字：implements

public class UserServiceImpl implements UserService,... {
	public void run() {
	}
}

作用

1. 约束
2. 定义一些方法，让不同的人实现
3. 方法都是抽象的
4. 属性都是常量
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口中的方法

内部类

在一个类的内部再定义一个类。一个java文件中可以有多个class文件，但是只能有一个public class

1. 成员内部类

package oop;

public class Outer {
    private int id = 10;
    public void out() {
        System.out.println("这是外部类");
    }
    public class Inner {
        public void in() {
            System.out.println("这是内部类");
        }
        //获得外部类的私有属性
        public void getId() {
            System.out.println(id);
        }
    }
}

package oop;

public class Outer {
    private int id = 10;
    public void out() {
        System.out.println("这是外部类");
    }
    public class Inner {
        public void in() {
            System.out.println("这是内部类");
        }
        //获得外部类的私有属性
        public void getId() {
            System.out.println(id);
        }
    }
}

2. 静态内部类

package oop;

public class Outer {
    private int id = 10;
    public void out() {
        System.out.println("这是外部类");
    }
    public static class Inner {
        public void in() {
            System.out.println("这是内部类");
        }
        //获得外部类的私有属性，报错
        /*
        public void getId() {
            System.out.println(id);
        }
        */
    }
}

3.局部内部类

package oop;

public class Outer {
    private int id = 10;
    public void out() {
        System.out.println("这是外部类");
    }
    public void method() {
        class Inner {
        }
    }
}

4.匿名内部类

package oop;

public class Main {
    
    public static void main(String[] args) {
		//不需要保存到变量中
        new A().eat();

    }
    
}

class A {
    public void eat() {
        System.out.println("eat");
    }
}