面向对象复习（java)

包

作用：1. 区分相同名字的类，2. 当类很多时，可以很好管理类，3. 控制访问范围

如果类用了包，类名就是 包 + 类名
包的本质就是文件夹

---

---

在本地 cmd 编译

本地使用包，要用 java -d + 编译后存放的目录 + java 源文件路径 ,-d 会自动生成包(文件夹）

---

---

包规则

• 包名命名规范中要求全部小写
• 包名命名规范：公司域名 + 项目名 + 模块名 + 功能名

---

---

import(导包）

假设 main 类在 A 包，Utils 类在 B 包

用到别的包的东西，必须要用 包名 + 类名 访问
因为类名已经变成（类名 + 包名了）

package A;

public class Main {
    public static void main(String[] args) {
       //静态方法：类名（包名+类名).方法名访问
        B.Util.use();
    }
}

package B;

public class Util {
    public static void use() {
        System.out.println("调用到了 B 包下的 use");
    }

}

编译的时候记得两个类都要编译

---

在同一个包下的话，包名可以省略，如果不在同一个包，想省略，要用 import 导入包

import B.Util（表示可以省略 B）

package A;

//导入 表示导入 B 包里面的 Util（可以省略B）
import B.Util;

public class Main {
    public static void main(String[] args) {
      	//导入 B 包了 所以包名可以省略
        Util.use()
    }
}

package B;

public class Util {
    public static void use() {
        System.out.println("调用到了 B 包下的 use");
    }

}

---

举几个例子：

import java.lang.System;//表示可以 java.lang.System 类可以省略 java.lang
import java.lang.Math;//表示可以使用 java.lang.Math 可以省略 java.lang
import static java.lang.Math.sin;// static java.lang.Math.sin 可以省略 java.lang.Math
import static java.lang.Math.* //表示 static java.lang.Math 下的所有 方法和变量可以省略 java.lang.Math 

//语法糖
import static java.lang.Math.*;
public class Main {
    public static void main(String[] args) {
        double a = sin(13.1);
    }
}

注意

- java.lang. * 包会系统会自动导入

• import 语句只能出现在 package 和 class 定义之间
• import java.util.*：这个 * 表示导入 java.util包下的所有类，这个会浪费元空间

---

---

---

this

• this 表示对当前对象的引用
• this 存储在 实例方法帧栈的局部变量表 第 0 个位置
• 在构造方法中只能出现在第一行
• static 方法中 不能用 this ，因为帧栈表中没有
• 可以用来区分当前类的属性和局部变量

---

---

this 访问实例方法

this.方法名（参数列表）

public class Test {
    public static void main(String[] args) {
        new A().m1();
    }
}


class A {
    void m1() {
    	//调用 m2
        this.m2();
    }

    void m2() {
        System.out.println("调用到 m2 了");
    }
}

---

---

this 访问构造方法

访问构造器语法：this(参数列表); 注意只能在构造器中使用

public class Test {
    public static void main(String[] args) {
        new A();
    }
}


class A {
    int a = 0;

    public A() {
    	//调用另一个构造
        this(10);
    }

    public A(int a) {
        this.a = a;
        System.out.println("调用到另一个构造了");
    }


}

---

---

---

super

super 代表父类的引用，用于访问父类的属性，方法，构造器

---

• 访问父类的属性，但是不能访问父类的 private 属性，语法：super.属性名

---

• 访问父类的方法，不能访问父类 private 方法，语法：super.方法名(参数列表）

---

• 访问父类构造器，语法：super(参数列表)，只能放在构造器第一句，只能出现一句

---

super 访问父类构造器

public class Test {
    public static void main(String[] args) {
        new B(10);
    }
}


class A {
    int a = 10;

    public A(int a) {
        System.out.println("调用了父类构造");
        this.a = a;
    }
}

class B extends A{
    //调用父类构造，在构造本类
    public B(int a) {
        super(a);
    }
}

---

super访问父类方法

public class Test {
    public static void main(String[] args) {
        new B().sm();
    }
}


class A {
    int a = 10;
    public A(){};

    public void fm() {
        System.out.println("调用到了父类方法");
    }
}

class B extends A{
    //调用父类构造，在构造本类
    public void sm() {
        super.fm();
    }

}

---

super 访问父类属性

public class Test {
    public static void main(String[] args) {
        new B().sm();
    }
}


class A {
    int a = 10;
    public A(){};

}

class B extends A{

    int a = 20;

    public void sm() {
        //这里输出的是父类的 a
        System.out.println(super.a);
    }

}

---

如果多个基类（上下类中）都有同名成员，使用 super 访问遵循就近原则，也就是从父类开始一直找到 Object 类

---

---

super 和 this 区别
一个是从本类开始找到 Object , 一个是从 父类开始找到 Object

---

---

---

构造方法

• 一个类可以定义多个不同的构造器，即构造器重载
• 构造器名要和类名相同
• 构造器是完成对象的初始化
• 在创建对象时，系统自动调用该类的无参构造
• 如果没有构造器就默认调用无参构造，系统会自动生成
• 如果定义了有参构造，那就不会自动生成无参构造

---

---

---

访问权限

---

---

---

封装

没有 static 修饰的类中的变量 叫 实例变量
没有 static 修饰的类中的变量 叫 实例方法

封装就是把对象所有 “状态”(属性)，”行为“(方法) 统一封装到一个类中，隐藏了对象内部的具体实现细节，向外界提供有限的访问接口，实现对象的保护

---

---

代码实现

1. 属性私有化
2. 对外提供public 的 get set 方法

class A {
    private int a;
    private int b;

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }
}

---

---

---

继承

当多个类存在相同 属性，方法，从这些类可以抽象出父类，在父类中定义这些相同的属性和方法，所有子类不需要重写定义这些方法，继承就行

java 是单继承机制

---

细节

• 除了构造方法和私有的不继承下来，其他都继承下来

---

• 子类构造的时候父类一定会先构造，而且默认情况调无参构造，如果没有无参构造，就要用 super 去指定父类哪个构造器，完成初始化工作

---

• super() 和 this() 都只能放在构造器第一行，所以，两个方法不能共存在一个构造器

---

• 所有类的顶层父类都是 Object 类

---

• 用据称必须满足 is-a(泛化关系) ，例如 Cat is Animal

---

---

方法重写(覆盖)

发生覆盖的条件

• 具有继承关系
• 相同的返回值类型，相同的方法名，相同的形参列表
• 访问权限不能变低，可以变高 （public protected, 默认，private【最低】)
• 抛出异常不能变多，可以变少
• 返回值类型可以是父类方法返回值类型的子类
• 方法覆盖说的是实例方法，和实例变量无关

---

---

子父类同名变量问题

public class Test {
    public static void main(String[] args) {
        new B().test();
    }
}


class A {
    int a;
}

class B extends A{
    int a = 10;

    public void test() {
        //调用父类 a
        System.out.println(super.a);
        //调用当前类 a
        System.out.println(this.a);
        System.out.println(a);
    }
}

---

---

关于子父类方法的继承问题

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

        // test 方法继承到 B 但是返回的还是 父类的 a
        // 因为这个方法的源头就是 a,通过虚函数表传承了
        // 除非是重写了 test 方法
        System.out.println(new B().test());
    }
}


class A {
    int a;

    public int test() {
        return a;
    }
}

class B extends A{
    int a = 10;
}

---

---

---

多态

降低耦合度，提高程序过程

---

向上转型和向下转型

向上转型

父类引用指向子类对象
编译类型看左边，允许类型看右边

public class Test {
    public static void main(String[] args) {
        //向上转型
        father f = new Son();
    }
}


class father{
    
}

class Son extends father {
    
}

编译类型决定了，能调用哪些东西，也就是子类独有的就用不了了需要向下转型，才能访问

运行时：先找本类，如果有则调用，如果没有则找父类，再没有就父类的父类

---

向下转型

强制转换成子类类型

public class Test {
    public static void main(String[] args) {
        //向上转型
        father f = new Son();
        //向下转型
        Son s = (Son) f;
    }
}


class father{

}

class Son extends father {

}

向下转型后，可以调用子类类型中所有的成员

---

---

动态绑定机制

1. 当调用对象方法时，该方法会和该对象的运行类型绑定
2. 当调用读写属性时候，没有动态绑定机制，哪里声明，哪里使用

属性直接访问看编译类型，如果是在函数里面就哪里声明用哪里的无动态绑定机制

举例

public class Test {
    public static void main(String[] args) {
        //向上转型
        father f = new Son();
        //返回 10，因为父类声明了，就用父类的
        f.fm(); 
    }
}


class father{
    
    int a = 10;
    
    public int fm() {
        return a;
    }

}

class Son extends father {
    int a = 11;
}

---

---

---

IDEA 常用快捷键

• 切换选项卡：alt + 左右方向键
• 自动是生成变量：.var
• 删除一行：ctrl + y
• 查找某个类：敲两次 shift
• for 快捷键：for+变量名
• 在一个类中寻找方法 ctrl + F12
• 单行注释： ctrl + /
• 多行注释： ctrl + shift + /
• 多行编辑：按 alt 别松手，鼠标拖动多行，完成多行编辑
• 查看源码：按 ctrl 别松手，鼠标移动到对应的类名下，出现下划线，点进去
• 快速向下转型并生成变量名：变量名.castvar

---

---

---

JVM 体系结构

---

这只是规范，想要如何设置还是看实现

符号引用：类名， 属性名，方法名
本地方法栈：有 native 的方法就往这里压

---

---

---

Hotpot 实现

JDK 6

---

JDK7

---

JDK8以后

---

程序运行