Hi i,m JinXiang
⭐ 前言 ⭐
本篇文章主要介绍Java面向对象编程（基础部分）类与对象、方法重载、作用域、构造器细节、this关键字、可变参数使用以及部分理论知识
🍉欢迎点赞 👍 收藏 ⭐留言评论 📝私信必回哟😁
🍉博主收将持续更新学习记录获，友友们有任何问题可以在评论区留言
目录
一、类与对象（oop）
1.1、类与对象概述
1.2、类与对象的关系示意图
上图说明
1.3、面向对象快速入门（代码直接示例）
1.4、对象内存布局
1.5、属性 / 成员变量概念
基本介绍
属性使用注意细节
1.6、创建对象访问属性
如何创建对象
如何访问属性
1.7、对象分配机制（重）
1.8、对象创建过程
1.9、成员方法
成员方法基本介绍
成员方法快速入门
代码演示上方例题
方法的调用机制
方法调用小结
使用成员方法的好处
成员方法的定义
注意事项和使用细节
类定义的完善
方法传参机制
基本数据类型的传参机制
引用数据类型的传参机制
结果：
克隆对象
递归
基本介绍
递归能解决什么问题
打印问题
阶乘问题
递归重要规则
递归练习题
1、斐波那契
2、猴子吃桃
二、方法重载
基本介绍
重载的好处
重载的快速使用
注意事项和使用细节
课堂练习
练习1、判断题
练习2、代码题
可变参数
快速入门案例
可变参数注意事项和使用细节
可变参数练习
三、作用域
基本介绍
上述说明举例
注意事项和使用细节
四、构造方法/构造器
基本介绍
看问题需求
基本语法
思路说明
基本介绍（小结）
快速入门举例
注意事项和使用细节
对象创建流程分析（包构造器版）
练习
练习1
练习2
五、this关键字
基本介绍
编辑this本质
this小结
this注意事项和使用细节
this课堂练习
一、类与对象（oop）
1.1、类与对象概述
对象（属性，行为）
类：自定义数据
int : Java提供的数据类型
1.2、类与对象的关系示意图
上图说明
- 1、创建一个对象
- 2、实例化一个对象
- 3、把类实例化
1.3、面向对象快速入门（代码直接示例）
package com.example.han_severejava.面向对象;
public class 类与对象引出 {
public static void main(String[] args) {
/*
张老太养了两只猫猫:一只名字叫小白,今年3岁，白色。
还有一只叫小花,今年100岁,花色。请编写一个程序，当用户输入小猫的名字时，
就显示该猫的名字，年龄， 颜色。 如果用户输入的小猫名错误，
则显示张老太没有这只猫猫。
*/
//1、创建一只猫new Cat()（猫对象）
//2、Cat cat1 = new Cat() 把创建的猫赋给cat1
//3、cat1就是一个对象
Cat cat1 = new Cat();
cat1.name = "小白";
cat1.age = 3;
cat1.color = "白色";
//创建了第二只猫 并赋给cat2
//cat2也是一个对象（猫对象）
Cat cat2 = new Cat();
cat2.name = "小花";
cat2.age = 100;
cat2.color = "花色";
//怎么使用（如何访问对象）
System.out.println("第1只猫的==》姓名："+cat1.name+" 年龄："+cat1.age+" 颜色："+cat1.color);
System.out.println("第2只猫的==》姓名："+cat2.name+" 年龄："+cat2.age+" 颜色："+cat2.color);
}
}
//自定义一个类
class Cat{
//属性
String name;
int age;
String color;
}
1.4、对象内存布局
1.5、属性 / 成员变量概念
基本介绍
- 1、从概念或叫法上看: 成员变量 = 属性 = fieldr
- (即成员变量是用来表示属性的，授课中，统一叫属性)
- 案例演示: Car(name,age,color) ↑
- 2、属性是类的一个组成部分，一般是基本数据类型，也可是引用类型(对象，数组)。
- 比如我们前面定义猫类的int age就是属性
- 比如我们前面定义猫类的int age就是属性
属性使用注意细节
- 1、属性的定义语法同变量，示例:
- 访问修饰符（protected）
- 控制属性的访问范围
- 4种属性范围（public，protected，默认，private）
- 属性类型
- 属性名
- 访问修饰符（protected）
- 2、属性的定义类型可以为任意类型，包含基本类型或引用类型
- 3、属性如果不赋值，有默认值，规则和数组一致。
- 对象的属性默认值，遵守数组规则:
- int 0，short 0,byte 0,long 0,
- float 0.0,double 0.0，char \u0000，boolean false，String null
1.6、创建对象访问属性
如何创建对象
- 1、先声明再创建
- Cat cat1; //声明
- cat1 = new Cat; //创建
- 2、直接创建
- Cat cat2 = new Cat;
如何访问属性
- 对象名.属性名
- 如：cat1.name
- cat1.age
1.7、对象分配机制（重）
- 1、栈:一般存放基本数据类型(局部变量)
- 2、堆:存放对象(Cat cat ,数组等)
- 3、方法区:常量池(常量，比如字符串)，类加载信息
- 4、示意图[Cat (name, age, price)]
1.8、对象创建过程
- 1、先加载Person类信息(属性和方法信息,只会加载一次)
- 2、在堆中分配空间,进行默认初始化(看规则)
- 3、把地址赋给p,p就指向对象
- 4、进行指定初始化，比如：p.name = jack p.age = 10
1.9、成员方法
成员方法基本介绍
在某些情况下，我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外(年龄,
姓名..),我们人类还有一些行为比如:可以说话、 跑步..通过学习，还可以做算术题。这时就
要用成员方法才能完成。现在要求对Person类完善。
成员方法快速入门
- 1)添加speak成员方法输出我是一只好人
- 2)添加cal01成员方法，可以计算从1+..+ 1000的结果
- 3)添加cal02成员方法,该方法可以接收一个数n,计算从1+..+ n的结果
- 4)添加getSum成员方法可以计算两个数的和
代码演示上方例题
package com.example.han_severejava.面向对象;
import java.util.Scanner;
public class 成员方法快速入门 {
public static void main(String[] args) {
//方法使用
//1、先创建对象
Person person = new Person();
//2、再调用方法
person.speak();
person.cal01();
person.cal02();
}
}
class Person{
String name;
String age;
//方法
//1)添加speak成员方法输出我是一只好人
//解读：
// 1. public表示方法是公开
//2. void表示方法没有返回值
//3.speak() : speak是 方法名，() 形参列表
//4.{}方法体，可以写我们要执行的代码
public void speak(){
System.out.println("我是一个好人");
}
//2)添加cal01成员方法，可以计算从1+..+ 1000的结果
public void cal01(){
int count = 0;
for (int i = 1; i <= 1000 ; i++) {
count += i;
}
System.out.println("从1+...+到1000的结果是："+count);
}
//3)添加cal02成员方法,该方法可以接收一个数n,计算从1+..+ n的结果
public void cal02(){
Scanner input = new Scanner(System.in);
System.out.println("请输入一个数：");
int number = input.nextInt();
int count = 0;
for (int i = 1; i <= number ; i++) {
count += i;
}
System.out.println("从1开始+到"+number+"的结果是："+count);
}
//4)添加getSum成员方法可以计算两个数的和
}
方法的调用机制
方法调用小结
- 1.当程序执行到方法时，就会开辟一个独立的空间(栈空间)
- 2.当方法执行完毕，或者执行到return语句时，就会返回，
- 3.返回到调用方法的地方
- 4.返回后，继续执行方法后面的代码
- 5.当main方法(栈)执行完毕，整个程序退出
使用成员方法的好处
- 1、提高代码的复用
- 2、可以将实现的细节封装起来，然后供其他用户来调用即可
成员方法的定义
访问修饰符 返回数据类型 方法名（形参列表..）{ //方法体
语句;
return 返回值;
}
- 1)形参列表：表示成员方法输入cal(intn)，getSum(intnum1,intnum2)
- 2)返回数据类型：表示成员方法输出,void表示没有返回值
- 3)方法主体：表示为了实现某一功能代码块
- 4)return语句不是必须的。
注意事项和使用细节
- 访问修饰符(作用是控制方法使用的范围)
- 如果不写默认访问，[有四种:public,protected,默认,private],具体在后面说
- 返回数据类型
- 1)一个方法最多有一个返回值[思考，如何返回多个结果返回数组]
- 2)返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
- 3)如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return值;而且要求返回值类型必须和return的值类型一致或兼容
- 4)如果方法是void，则方法体中可以没有return语句，或者只写return;
- 方法名
- 遵循驼峰命名法，最好见名知义，表达出该功能的意思即可,比如得到两个数的和getSum,开发中按照规范
- 形参列表
- 1.一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，比如getSum(int n1,int n2)
- 2.参数类型可以为任意类型，包含基本类型或引用类型，比如printArr(intD[] map)
- 3.调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数! [getSum]
- 4.方法定义时的参数称为形式参数，简称形参;方法调用时的传入参数称为实际参数，简称实参,实参和形参的类型要一致或兼容、 个数、顺序必须致! [演示]
- 方法体
- 里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法!即:方法不能嵌套定义。[演示]
类定义的完善
方法传参机制
基本数据类型的传参机制
基本数据类型，传递的是值（值拷贝），形参的如何改变不影响实参！
引用数据类型的传参机制
B类中编写一个方法test100,可以接收一个数组， 在方法中修改该数组，看看原来的数组是否变化?
package com.example.han_severejava.面向对象;
public class 引用数据类型方法传参机制 {
public static void main(String[] args) {
Can_B b = new Can_B();
int[] arr = {1, 2, 3};
b.test100(arr);
System.out.println("mian中的arr数组：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
System.out.println();
}
}
class Can_B{
//B类中编写一个方法test100,可以接收一个数组， 在方法中修改该数组，看看原来的数组是否变化?
public void test100 (int[] arr){
arr[0] = 10;
System.out.println("test100的arr数组：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
System.out.println();
}
}结果：
引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！
克隆对象
package com.example.han_severejava.面向对象;
public class 克隆对象 {
public static void main(String[] args) {
Person_ p = new Person_();
p.name = "张三";
p.age = 18;
MyTools tools = new MyTools();
Person_ p2 = tools.copyPerson(p);
//到此 p 和 p2 都是Person_对象，但是 是两个独立的对象 属性相同
System.out.println("p的属性 age="+p.age+"名字="+p.name);
System.out.println("p2的属性 age="+p2.age+"名字="+p2.name);
}
}
class Person_ {
String name;
int age;
}
class MyTools{
//编写一个方法copyPerson,可以复制一个Person对象，返回复制的对象。克隆对象，
//注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同
//编写方法的思路
//1. 方法的返回类型 Person
//2.方法的名字copyPerson
//3.方法的形参(Person p)
//4.方法体，创建一个新对象，并复制属性，返回即可
public Person_ copyPerson(Person_ p){
//创建一个新对象
Person_ p2 = new Person_();
p2.name = p.name; //把原来的名字赋给p2.name
p2.age = p.age;
return p2;
}
}
递归
基本介绍
简单的说:递归就是方法自己调用自己，每次调用时传入不同的变量，递归有助于编程者解决
复杂问题,同时可以让代码变得简洁
递归能解决什么问题
- 各种数学问题如:
- 8皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题(google编程大赛)[简单演示]
- 各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等.
- 将用栈解决的问题-- >递归代码比较简洁
- 列举两个小案例,来帮助大家理解递归调用机制
- 1)打印问题
- 2)阶乘问题
打印问题
package com.example.han_severejava.面向对象;
public class 递归打印问题 {
public static void main(String[] args) {
T t1 = new T();
t1.test(4);
}
}
class T{
//分析
public void test(int n){
if (n>2){
test(n -1);
}
System.out.println("n="+n);
}
}
//结果为n=2,n=3,n=4方法分析
阶乘问题
package com.example.han_severejava.面向对象;
public class 递归打印问题 {
public static void main(String[] args) {
int res = t1.factorial(5);
System.out.println("res="+res);
}
}
class T{
//阶乘
public int factorial(int n){
if (n == 1){
return 1;
}else {
return factorial(n - 1) * n;
}
}
}
//结果为：120 ，详细步骤看方法解析方法分析
递归重要规则
- 1、执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
- 2、方法的局部变量是独立的，不会相互影响，比如n变量
- 3、如果方法中使用的是引用类型变量(比如数组，对象)，就会共享该引用类型的数据.
- 4、递归必须向退出递归的条件逼近，否则就是无限递归,出现循环出不来,死龟了:)
- 5、当一个方法执行完毕，或者遇到return,就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。
递归练习题
1、斐波那契
package com.example.han_severejava.面向对象;
public class 递归斐波那契 {
public static void main(String[] args) {
T_ t1 = new T_();
int number = 7; //输入的数字
int fibonacci = t1.Fibonacci(number);//计算得出的斐波那契数
if (fibonacci != -1){
System.out.println("当n="+number+"的时候,对应的斐波那契数="+fibonacci);
}
}
}
class T_{
public int Fibonacci(int n){
//请使用递归的方式求出斐波那契数1:1 ,2,3,5,8, 3...给你一个整数n,求出它的值是多
//思路分析
//1.当n=1斐波那契数是1
//2.当n=2斐波那契数是1
//3.当n>=3斐波那契数是前两个数的和
//4.这里就是一个递归的思路
if (n >= 1){
//如果n大于等于1的时候，执行下面操作
if (n == 1 || n == 2){
return 1;
}else {
return Fibonacci(n - 1) + Fibonacci(n - 2);
}
}else {
System.out.println("要求输入的n是>=1的整数");
return -1;
}
}
}
2、猴子吃桃
package com.example.han_severejava.面向对象;
public class 递归猴子吃桃 {
public static void main(String[] args) {
T__ t1 = new T__();
int day = 9;
int peachNum = t1.peach(day);
if (peachNum != -1){
System.out.println("第"+day+"天有"+peachNum+"个桃子");
}
}
}
class T__{
//猴子吃桃子问题:有一堆桃子，猴子第一天吃了其中的一 半，并再多吃了一个!以后
//每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时(即还没吃)
//发现只有1个桃子了。问题:最初共多少个桃子?
//思路分析(逆推)
//1.day=10时有1个桃子
//2. day =时有(day10 +. 1)*2=4
//3.day=8时有(day9+1)*2=10
//4.规律就是前一天的桃子 = (后一天的桃子+ 1) * 2
//5.递归
public int peach(int day){
if (day == 10){ //第10天，只有一个桃子
return 1;
}else if(day >=1 && day <=9){
return (peach(day + 1) + 1) * 2;
}else {
System.out.println("day在1-10");
return -1;
}
}
}
//结果：第9天有4个桃子
二、方法重载
基本介绍
- java中允许同一个类中，多个同名方法的存在，但要求形参列表不致！
- 比如: System.out.println(); out是PrintStream类型
重载的好处
- 1)减轻了起名的麻烦
- 2)减轻了记名的麻烦
重载的快速使用
package com.example.han_severejava.面向对象;
public class 方法重载快速入门 {
public static void main(String[] args) {
CZ1 cz = new CZ1();
//如何使用重载
//调用符合对象的名称
System.out.println(cz.calculate(1, 1));
}
}
class CZ1{
//两个整数的和
public int calculate(int n1,int n2){
return n1 +n2;
}
//一个整数，一个double的和
public double calculate(int n1,double n2){
return n1 +n2;
}
//一个double,一个Int和
public double calculate(double n2,int n1) {
return n1 +n2;
}
//三个int的和
public int calculate(int n1,int n2,int n3){
return n1 +n2 + n3;
}
}
//结果为：2注意事项和使用细节
- 1、方法名:必须相同
- 2、参数列表:必须不同(参数类型或个数或顺序，至少有一样不同，参数名无要求)
- 3、返回类型:无要求
课堂练习
练习1、判断题
与void show(int a,char b,double c){}构成重载的有: [ b c d e ]
a) void show(int x,char y,double z){} //不是
b) int show(int a,double c,char b){} //是
c) void show(int a,double c,char b){} //是
d) boolean show(int c,char b){} /是
e) void show(double c){} /是
f) double show(int x,char y,double z){} //不是
g) void shows(){} //不是
练习2、代码题
题目:编写程序，类Methods中定义 三个重载方法并调用。方法名为m。三个方法分
别接收一个int参数、两个int参数、 一个字符串参数。分别执行平方运算并输出
结果，相乘并输出结果，输出字符串信息。在主类的main ()方法中分别用参数
区别调用三个方法。
package com.example.han_severejava.面向对象;
public class 方法重载课堂练习2 {
public static void main(String[] args) {
// 在主类的main ()方法中分别用参数区别调用三个方法
CZ2 cz = new CZ2();
cz.m(10);//100
cz.m(10,20);//200
cz.m("你好");
}
}
class CZ2{
//编写程序，类Methods中定义 三个重载方法并调用。方法名为m。
// 三个方法分别接收一个int参数、两个int参数、 一个字符串参数。
// 分别执行平方运算并输出,结果，相乘并输出结果，输出字符串信息。
// 在主类的main ()方法中分别用参数区别调用三个方法。
//分析
//1 方法名 m
//2 形参（int）
//3 void
public void m(int n){
System.out.println("平方="+(n * n));
}
//1 方法名 m
//2 形参（int,int）
//3 void
public void m(int n1,int n2){
System.out.println("相乘="+(n1 * n2));
}
//1 方法名 m
//2 形参（String）
//3 void
public void m(String n){
System.out.println("传入的str="+n);
}
}
可变参数
●基本概念
- java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。
基本语法
访问修饰符 返回类型 方法名 (数据类型...形参名) {
}
快速入门案例
题目：可以计算 2个数的和，3个数的和，4，5。。
package com.example.han_severejava.面向对象;
public class 可变参数快速入门 {
public static void main(String[] args) {
VariableParameter v = new VariableParameter();
System.out.println(v.sum(5, 10, 11));
System.out.println(v.sum(105, 1, 51));
}
}
class VariableParameter{
//思路分析
//1. int... 表示接受的是可变参数，类型是int ,即可以接收多个int(0-多)
//2. 使用可变参数时，可以当做数组来使用即nums 可以当做数组
//3.遍历nums 求和即可
int res =0;
public int sum(int...nums){
for (int i = 0; i < nums.length; i++) {
res += nums[i];
}
return res;
}
}
结果：26，183
可变参数注意事项和使用细节
- 1)可变参数的实参可以为0个或任意多个。
- 2)可变参数的实参可以为数组。
- 3)可变参数的本质就是数组.
- 4)可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
- 5)一个形参列表中只能出现一个可变参数
可变参数练习
题目：有三个方法，分别实现返回姓名和两门课成绩(总分)，返回姓名和三门课成绩(总
分)，返回姓名和五门课成绩(总分)。封装成一个可变参数的方法
package com.example.han_severejava.面向对象;
public class 可变参数练习 {
public static void main(String[] args) {
CS cs = new CS();
System.out.println(cs.exercises("张三",80.0,100.0));
//System.out.println(cs.exercises("李四",80,100,1));
//System.out.println(cs.exercises("王五",80,100,1,10,100));
}
}
class CS{
//有三个方法，分别实现
// 返回姓名和两门课成绩(总分)，
// 返回姓名和三门课成绩(总分)，
// 返回姓名和五门课成绩(总分)。
// 封装成一个可变参数的方法
public String exercises(String name, double...sums) {
int count = 0;
for (int i = 0; i < sums.length; i++) {
count += sums[i];
}
return name + "有" + sums.length + "科的成绩总分为：" + count;
}
}结果：张三有2科的成绩总分为：180
三、作用域
基本介绍
面向对象中，变量作用域是非常重要知识点，相对来说不是特别好理解，请大家注
意听，认真思考，要求深刻掌握变量作用域。
- 1、在java编程中，主要的变量就是属性(成员变量)和局部变量。
- 2、我们说的局部变量-般是指在成员方法中定义的变量。【举例 Cat类: cry】
- 3、java中作用域的分类
- 全局变量：也就是属性，作用域为整个类体Cat类: cry eat等方法使用属性
- 局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中!
- 4、全局变量可以不赋值，直接使用，因为有默认值，局部变量必须赋值后，才能使用，因为没有默认值。
上述说明举例
package com.example.han_severejava.面向对象;
public class 作用域快速入门 {
public static void main(String[] args) {
}
}
class Cat1{
//全局变量：也就是属性，作用域为整个类体Cat类: cry eat等方法使用属性
//属性在定义时 ，可以直接赋值
//age的作用域就是在全局中（在全局中都可以使用）
int age =18; //age就是
public void cry() {
//1.局部变量-般是指在成员方法中定义的变量。
//2.n 和 name 就是局部变量
//3.n 和 name 的作用域就是在cry方法中
int n = 18;
String name = "jack";
}
}
注意事项和使用细节
- 1、属性和局部变量可以重名，访问时遵循就近原则。
- 2、在同一个作用域中，比如在同一一个成员方法中，两个局部变量，不能重名。[举例]
- 3、属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。
- 4.、作用域范围不同
- 全局变量/属性:可以被本类使用，或其他类使用(通过对象调用)
- 局部变量:只能在本类中对应的方法中使用
- 5、修饰符不同
- 全局变量/属性可以加修饰符
- 局部变量不可以加修饰符
四、构造方法/构造器
基本介绍
看问题需求
我们来看一个需求:前面我们在创建人类的对象时，是先把一个对象创建好后，再给
他的年龄和姓名属性赋值，如果现在我要求，在创建人类的对象时，就直接指定这个
对象的年龄和姓名，该怎么做?这时就可以使用构造器。
基本语法
[修饰符] 方法名 ( 形参列表 ) {
方法体;
}
思路说明
- 1)构造器的修饰符可以默认
- 2)构造器没有返回值
- 3)方法名和类名字必须样
- 4)参数列表和成员方法一样的规则
- 5)构造器的调用系统完成
基本介绍（小结）
构造方法又叫构造器(constructor),是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点:
- 1)方法名和类名相同
- 2)没有返回值
- 3)在创建对象时，系统会自动的调用该类的构造器完成对对象的初始化。
快速入门举例
package com.example.han_severejava.面向对象;
public class 构造器快速入门 {
public static void main(String[] args) {
//当我们new 一个对象时，直接通过构造器指定名字和年龄
Person_GZQ p1 = new Person_GZQ("Smith", 80);
System.out.println("p1的属性如下：");
System.out.println("对象姓名："+p1.name); //Smith
System.out.println("对象年龄："+p1.age); //80
}
}
//在创建人类的对象时，就直接指定这个对象的年龄和姓名
class Person_GZQ{
String name;
int age;
//构造器
//思路分析
//1、构造器没有返回值
//2、构造器的名称和Person_GZQ类名必须一样
//3、(String pName,int pAge)是构造器形参列表，规则和成员方法-样
public Person_GZQ(String pName,int pAge){
System.out.println("构造器被调用~~完成对象的属性初始化");
name = pName;
age = pAge;
}
}
注意事项和使用细节
- 1. 一个类可以定义多个不同的构造器，即构造器重载
- 比如:我们可以再给Person类定义一个构造器,用来创建对象的时候,只指定人名，不需要指定年龄
- 2.构造器名和类名要相同
- 3.构造器没有返回值
- 4.构造器是完成对象的初始化，并不是创建对象
- 5.在创建对象时,系统自动的调用该类的构造方法
- 6.如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)，比如Dog (){}, 使用javap指令反编译看看
- 7.一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下,即: Dog){} 写(这点很重要)
对象创建流程分析（包构造器版）
学习完构造器后
,
我们类的定义就应该更加完善了
练习
练习1
题目：在前面定义的Person类中添加两个构造器:
第一个无参构造器:利用构造器设置所有人的age属性初始值都为18
结果：
练习2
题目：第二个带pName和pAge两个参数的构造器:使得每次创建Person对象的同
时初始化对象的age属性值和name属性值。分别使用不同的构造器，创建对
象.
结果：
五、this关键字
基本介绍
java虚拟机会给每个对象分配this,代表当前对象。坦白的讲，要明白this不是件容易的事，我给大家打一个比方。[上帝创世界小故事]
this本质
this小结
this注意事项和使用细节
- 1)this关键字可以用来访问本类的属性、方法、构造器
- 2)this用于区分当前类的属性和局部变量
- 3)访问成员方法的语法：this.方法名(参数列表);
-
4) 访问构造器语法： this( 参数列表 ); 注意只能在构造器中使用 ( 即只能在构造器中访问另外一个构造器 ,必须放在第一条语句)
-
5)this不能在类定义的外部使用，只能在类定义的方法中使用。
this课堂练习
定义Person类，里面有name、ge属性，并提供compareTo比较方法，用于判断是否和另一个人相等，提供测试类TestPerson用于测试,名字和年龄完全一样，就返回true,否则返回false
总结不易，希望宝宝们不要吝啬亲爱的👍哟(＾Ｕ＾)ノ~ＹＯ！如有问题，欢迎评论区批评指正😁
