【Java基础学习】面向对象编程

开始时间: April 10, 2024
结束时间: April 16, 2024
阶段: Done

基础部分

类与对象的关系

类是抽象的，概念的，代表一类事物
对象是具体的，实际的，代表一个具体事物（实例）
类是对象的模板，对象是类的一个个体，对应一个实例

对象在内存中存在形式

class Cat{String name;int age;String color;
}// new 的过程：加载类的信息
// 属性信息
// 方法信息
Cat cat = new Cat();
cat.name = "Root";
cat.age = 18;
cat.color = "white";

请添加图片描述

类和对象的内存分配机制

栈：一般存放基本数据类型(局部变量)
堆：存放对象(Cat cat , 数组等)
方法区：常量池(常量，比如字符串)， 类加载信息

Java 创建对象的流程简单分析

Person p = new Person();
p.name = “jack”;
p.age = 10

先加载 Person 类信息(属性和方法信息, 只会加载一次)
在堆中分配空间, 进行默认初始化(看规则)
把地址赋给 p , p 就指向对象
进行指定初始化，比如 p.name ="jack",p.age = 10

方法的调用机制

1、当程序执行到方法时，就会开辟一个独立的空间(栈空间)
2、当方法执行完毕，或者执行到return语句时，就会返回结果值(void无返回值)
3、回到调用方法的地方
4、继续执行方法后面的代码
5、当 main 方法(栈)执行完毕，整个程序退出

Person peo = new Person();
int res = peo.getSum(10,20);
System.out.println("getSum Method return = " + res);public int getSum(int num1, int num2){int res = num1 + num2;return res;
}

请添加图片描述

成员方法传参机制

基本数据类型的传参机制【值拷贝】
引用数据类型的传参机制【地址拷贝】

方法重载【overload】

Java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致
注意事项和使用细节
- 方法名：必须相同
- 形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）
- 返回类型：无要求

可变参数

Java 允许将同一个类中多个同名、同功能、参数个数不同的方法，封装成一个方法。通过可变参数实现。

public class Method{public static void main(String[] args){tool t = new tool();System.out.println(t.sum(1,2,3));}
}class tool{/*** 访问修饰符 返回类型 方法名(数据类型... 形参名) {}*/public int sum(int ... nums){int res = 0;for(int i = 0; i < nums.length; i++){res += nums[i];}return res;}
}

注意事项和使用细节
- 可变参数的实参可以为0个或任意多个
- 可变参数的实参可以为数组
- 可变参数的本质就是数组
- 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
- 一个形参列表中只能出现一个可变参数

构造方法/构造器【constructor】

主要作用是完成对新对象的初始化
- 方法名和类名相同
- 没有返回值
- 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化

对象创建的流程

class Person{int age = 90;String name;Person(String n, int a){ //构造器name = n;age = a;}
}
Person p = new Person("FOUR_A",18);

流程分析：

加载Person类信息(Person.class)，只会加载一次
在堆中分配空间（地址）
完成对象初始化
- 默认初始化：age = 0 name = null
- 显式初始化：age = 90,name = null
- 构造器的初始化：age = 18, name = FOUR_A
对象在堆中的地址返回给p（p是对象名，也可以理解成是对象的引用）

this关键字

Java虚拟机会给每个对象分配this，代表当前对象

public class This{public static void main(String[] args){Dog dog = new Dog("FOUR_A",18);dog.info();}
}class Dog{public String name;public int age;// 构造器public Dog(String name, int age){this.name = name;this.age = age;}public void info(){System.out.println("name = " + this.name + "age = " + this.age);}
}

请添加图片描述

this 的注意事项和使用细节

this 关键字可以用来访问本类的属性、方法、构造器
this 用于区分当前类的属性和局部变量
访问成员方法的语法：this.方法名(参数列表);
访问构造器语法：this(参数列表); 注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一
条语句)
this 不能在类定义的外部使用，只能在类定义的方法中使用

中级部分

IDE快捷键

删除当前行, 默认是 ctrl + Y 自己配置 ctrl + d
复制当前行, 自己配置 ctrl + alt + 向下光标
补全代码alt + /
添加注释和取消注释 ctrl + / 【第一次是添加注释，第二次是取消注释】
导入该行需要的类先配置 auto import , 然后使用 alt+enter 即可
快速格式化代码 ctrl + alt + L
快速运行程序自己定义 alt + R
生成构造器等 alt + insert【提高开发效率】
查看一个类的层级关系 ctrl + H[学习继承后，非常有用]
将光标放在一个方法上，输入 ctrl + B , 可以定位到方法 [学继承后，非常有用]
自动的分配变量名 , 通过在后面假 .var[老师最喜欢的]
模板快捷键

包

**包的本质：**创建不同的文件夹/自录来保存类文件

包的作用：

区分相同名字的类
当类很多时，可以很好的管理类
控制访问范围

包的命名：com.公司名.项目名.业务模块

访问修饰符

访问修饰符	本类	同包	子类	不同包
public	✔️	✔️	✔️	✔️
protect	✔️	✔️	✔️	❌
default	✔️	✔️	❌	❌
private	✔️	❌	❌	❌

面向对象编程三大特征

封装【encapsulation】

把抽象出的数据【属性】和对数据的操作【方法】封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作【方法】，才能对数据进行操作。
封装的实现步骤
- 将属性进行私有化 private 【不能直接修改属性】
- 提供一个公共的set方法，用于对属性判断并赋值
```
// Xxx表示某个属性
public void setXxx(类型参数名){//加入数据验证的业务逻辑属性=参数名:
}
```
- 提供一个公共的(public)get方法，用于获取属性的值
```
public dataType getXxx(){ //权限判断,再返回Xxx某个属性return XX;
}
```

继承

当两个类的属性和方法有很多是相同的，可以用继承提高代码的复用性
继承的基本语法
```
class childClass extends parentClass{}
```
子类就会自动拥有父类定义的属性和方法
父类又叫超类，基类.
子类又叫派生类。
继承的细节问题
- 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问,，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
- 子类必须调用父类的构造器，完成父类的初始化
- 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译
- 如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表)
- super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)
- super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
- java 所有类都是 Object 类的子类, Object 是所有类的基类
- 父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)
- 子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制

继承的内存布局

public class ExtendsTheory{public static void main(String[] args){Son son = new Son();}
}class GrandPa{String name = "grandpa";String hobby = "buybuybuy";
}class Father extends GrandPa{String name = "father";int age = 38;
}class Son extends Father{String name = "son";
}

请添加图片描述

super 关键字

super 代表父类的引用，用于访问父类的属性、方法、构造器
super 和 this 的比较

区别点	this	super
访问属性	访问本类中的属性，如果本类没有此属性则从父类中继续查找	从父类开始查找属性
调用方法	访问本类中的方法，如果本类没有此方法则从父类继续查找	从父类开始查找方法
调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在构造器的首行
特殊	表示当前对象	子类中访问父类对象

方法重写

方法覆盖(重写)就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法
注意事项和使用细节
- 子类的方法的形参列表,方法名称，要和父类方法的形参列表，方法名称完全一样。
- 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
- 子类方法不能缩小父类方法的访问权限
对方法的重写和重载做一个比较

名称	发生范围	方法名	形参列表	返回类型	修饰符
重载【overload】	本类	必须一样	类型、个数、顺序至少有一个不同	无要求	无要求
重写【override】	父子类	必须一样	必须一样	子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类	子类方法不能缩小父类方法的访问权限

多态

方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的
对象的多态
- 一个对象的编译类型和运行类型可以不一致
- 编译类型在定义对象时，就确定了，不能改变
- 运行类型是可以变化的
- 编译类型看定义时=号的左边，运行类型看=号的右边
```
//animal : 编译类型， Dog : 运行类型
Animal animal = new Dog(); //animal 的运行类型变成了 Cat
animal = new Cat();
```
多态注意事项和细节
- 多态的前提是：两个对象(类)存在继承关系
- 多态的向上转型
  - Animal animal = new Cat(); // Cat->Animal
  - 可以调用父类【Animal】中的所有成员(需遵守访问权限)
  - 不能调用子类【Cat】中特有成员
  - 最终运行效果看子类的具体实现
- 多态向下转型
  - Cat cat =(Cat)animal; // Animal->Cat
  - 只能强转父类【animal】的引用，不能强转父类的对象【Cat()】
  - 要求父类的引用必须指向的是当前目标类型的对象
  - 当向下转型后，可以调用子类类型中所有的成员

Java 的动态绑定机制

当调用对象方法的时候，该方法会和该对象【运行类型】的内存地址/运行类型绑定
当调用对象属性时，没有动态绑定机制，哪里声明，那里使用

Object 类

== 和 equals 的对比
- ==: 一个比较运算符
  - 既可以判断基本类型，又可以判断引用类型
  - 如果判断基本类型，判断的是值是否相等
  - 如果判断引用类型，判断的是地址是否相等
- equals: Object类中的方法，只能判断引用类型
  - 默认判断的是地址是否相等
  - 子类中会重写该方法，用于判断内容是否相等