面向对象复习（java)

文章目录

包
- 在本地 cmd 编译
- 包规则
- import(导包）
this
- this 访问实例方法
- this 访问构造方法
super
- super 访问父类构造器
- super访问父类方法
- super 访问父类属性
构造方法
访问权限
封装
继承
- 细节
- 方法重写(覆盖)
- 子父类同名变量问题
- 关于子父类方法的继承问题
多态
- 向上转型和向下转型
- 动态绑定机制
IDEA 常用快捷键
JVM 体系结构

包

作用：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() {//调用 m2this.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() {//这里输出的是父类的 aSystem.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() {//调用父类 aSystem.out.println(super.a);//调用当前类 aSystem.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 {}

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

动态绑定机制

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

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

举例

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