开始时间: 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类中的方法，只能判断引用类型
    • 默认判断的是地址是否相等
    • 子类中会重写该方法，用于判断内容是否相等