文章目录
Java面向对象编程（类、对象、方法、重载、可变参数、作用域、构造器、this本质）一、类与对象1. 类与对象的引出2. 使用现有技术解决3. 现有技术解决的缺点分析4. 类与对象的关系示意图5. 类和对象的区别和联系6. 对象在内存中存在形式(重要的)必须搞清楚。7. 属性/成员变量/字段8. 注意事项和细节说明9. 如何创建对象10. 如何访问属性11. 类和对象的内存分配机制(重要)1. Java 内存的结构分析2. Java 创建对象的流程简单分析 二、成员方法1.基本介绍2. 成员方法快速入门3. 方法的调用机制原理：(重要!-示意图!!!)4. 成员方法的好处5. 成员方法的定义6. 注意事项和使用细节7. 返回数据类型8. 方法名9. 方法体10. 方法调用细节说明11. 类定义的完善 三、成员方法传参机制(非常非常重要)1. 基本数据类型的传参机制2. 引用数据类型的传参机制 四、方法重载(OverLoad)1. 基本介绍2. 重载的好处3. 快速入门案例4. 注意事项和使用细节 五、可变参数1. 基本概念2. 基本语法3. 快速入门案例(VarParameter01.java)4. 注意事项和使用细节 六、作用域1. 基本使用2. 注意事项和细节使用 七、构造方法/构造器1. 看一个需求2. 基本语法3. 基本介绍4. 快速入门5. 注意事项和使用细节 八、对象创建的流程分析九、this 关键字1. 先看一段代码,并分析问题2. 深入理解 this3. this 的注意事项和使用细节Java面向对象编程（类、对象、方法、重载、可变参数、作用域、构造器、this本质）
提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。
提示：以下是本篇文章正文内容，下面案例可供参考
一、类与对象
1. 类与对象的引出
张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。还有一只叫小花,今年 100 岁,花色。请编写一个程序，当用户
输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示 张老太没有这只猫猫。
2. 使用现有技术解决
单独的定义变量解决使用数组解决3. 现有技术解决的缺点分析
不利于数据的管理
效率低===》 引出我们的新知识点 类与对象 哲学, 道家思想
java 设计者 引入 类与对象(OOP) ，根本原因就是现有的技术，不能完美的解决新的新的需求.
public class Object01 {//编写一个 main 方法public static void main(String[] args) {/*张老太养了两只猫猫:一只名字叫小白,今年 3 岁,白色。还有一只叫小花,今年 100 岁,花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示 张老太没有这只猫猫。*///单独变量来解决 => 不利于数据的管理(你把一只猫的信息拆解)//第 1 只猫信息// String cat1Name = "小白";// int cat1Age = 3;// String cat1Color = "白色";// //第 2 只猫信息// String cat2Name = "小花";// int cat2Age = 100;// String cat2Color = "花色";//数组 ===>(1)数据类型体现不出来(2) 只能通过[下标]获取信息，造成变量名字和内容// 的对应关系不明确(3) 不能体现猫的行为//第 1 只猫信息// String[] cat1 = {"小白", "3", "白色"};// String[] cat2 = {"小花", "100", "花色"};//使用 OOP 面向对象解决//实例化一只猫[创建一只猫对象]//老韩解读//1. new Cat() 创建一只猫(猫对象)//2. Cat cat1 = new Cat(); 把创建的猫赋给 cat1//3. cat1 就是一个对象Cat cat1 = new Cat();cat1.name = "小白";cat1.age = 3;cat1.color = "白色";cat1.weight = 10;//创建了第二只猫，并赋给 cat2//cat2 也是一个对象(猫对象)Cat cat2 = new Cat();cat2.name = "小花";cat2.age = 100;cat2.color = "花色";cat2.weight = 20;//怎么访问对象的属性呢System.out.println("第 1 只猫信息" + cat1.name+ " " + cat1.age + " " + cat1.color + " " + cat1.weight);System.out.println("第 2 只猫信息" + cat2.name+ " " + cat2.age + " " + cat2.color + " " + cat2.weight);}}//使用面向对象的方式来解决养猫问题////定义一个猫类 Cat -> 自定义的数据类型class Cat {//属性/成员变量String name; //名字int age; //年龄String color; //颜色//double weight; //体重//行为}
4. 类与对象的关系示意图
5. 类和对象的区别和联系
通过上面的案例和讲解我们可以看出:
类是抽象的，概念的，代表一类事物,比如人类,猫类…, 即它是数据类型.对象是具体的，实际的，代表一个具体事物, 即 是实例.类是对象的模板，对象是类的一个个体，对应一个实例
6. 对象在内存中存在形式(重要的)必须搞清楚。
7. 属性/成员变量/字段
基本介绍:
从概念或叫法上看： 成员变量 = 属性 = field(字段) （即 成员变量是用来表示属性的)
public class Object02 {//编写一个 main 方法public static void main(String[] args) {}}class Car {String name;//属性, 成员变量, 字段 fielddouble price;String color;String[] master;//属性可以是基本数据类型，也可以是引用类型(对象，数组)}
属性是类的一个组成部分，一般是基本数据类型,也可是引用类型(对象，数组)。比如我们前面定义猫类 的 int age 就是属性
8. 注意事项和细节说明
属性的定义语法同变量，示例：访问修饰符 属性类型 属性名;这里简单的介绍访问修饰符： 控制属性的访问范围有四种访问修饰符 public, proctected, 默认, private ,属性的定义类型可以为任意类型，包含基本类型或引用类型属性如果不赋值，有默认值，规则和数组一致。具体说: int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
public class PropertiesDetail {//编写一个 main 方法public static void main(String[] args) {//创建 Person 对象//p1 是对象名(对象引用)//new Person() 创建的对象空间(数据) 才是真正的对象Person p1 = new Person();//对象的属性默认值，遵守数组规则://int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String nullSystem.out.println("\n 当前这个人的信息");System.out.println("age=" + p1.age + " name=" + p1.name + " sal=" + p1.sal + " isPass=" + p1.isPass) ;}}class Person {//四个属性int age;String name;double sal;boolean isPass;}
9. 如何创建对象
先声明再创建Cat cat ; //声明对象 cat
cat = new Cat(); //创建直接创建
Cat cat = new Cat();
10. 如何访问属性
基本语法
对象名.属性名;
案例演示赋值和输出
cat.name ;
cat.age;
cat.color;
11. 类和对象的内存分配机制(重要)
1. Java 内存的结构分析
栈： 一般存放基本数据类型(局部变量)堆： 存放对象(Cat cat , 数组等)方法区：常量池(常量，比如字符串)， 类加载信息示意图 [Cat (name, age, price)]2. Java 创建对象的流程简单分析
Person p = new Person();p.name = “jack”;p.age = 10
先加载 Person 类信息(属性和方法信息, 只会加载一次)在堆中分配空间, 进行默认初始化(看规则)把地址赋给 p , p 就指向对象进行指定初始化， 比如 p.name =”jack” p.age = 10
二、成员方法
1.基本介绍
在某些情况下，我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外( 年龄，姓名…),我们人类还有一
些行为比如:可以说话、跑步…,通过学习，还可以做算术题。这时就要用成员方法才能完成。现在要求对 Person 类完善
2. 成员方法快速入门
添加 speak 成员方法,输出 “我是一个好人”添加 cal01 成员方法,可以计算从 1+…+1000 的结果添加 cal02 成员方法,该方法可以接收一个数 n，计算从 1+…+n 的结果添加 getSum 成员方法,可以计算两个数的和代码：
public class Method01 {//编写一个 main 方法public static void main(String[] args) {//方法使用//1. 方法写好后，如果不去调用(使用)，不会输出//2. 先创建对象 ,然后调用方法即可Person p1 = new Person();p1.speak(); //调用方法p1.cal01(); //调用 cal01 方法p1.cal02(5); //调用 cal02 方法，同时给 n = 5p1.cal02(10); //调用 cal02 方法，同时给 n = 10//调用 getSum 方法，同时 num1=10, num2=20//把 方法 getSum 返回的值，赋给 变量 returnResint returnRes = p1.getSum(10, 20);System.out.println("getSum 方法返回的值=" + returnRes);}}class Person {String name;int age;//方法(成员方法)//添加 speak 成员方法,输出 “我是一个好人”//老韩解读//1. public 表示方法是公开//2. void ： 表示方法没有返回值//3. speak() : speak 是方法名， () 形参列表//4. {} 方法体，可以写我们要执行的代码//5. System.out.println("我是一个好人"); 表示我们的方法就是输出一句话public void speak() {System.out.println("我是一个好人");}//添加 cal01 成员方法,可以计算从 1+..+1000 的结果public void cal01() {//循环完成int res = 0;for(int i = 1; i <= 1000; i++) {res += i;}System.out.println("cal01 方法 计算结果=" + res);}//添加 cal02 成员方法,该方法可以接收一个数 n，计算从 1+..+n 的结果//老韩解读//1. (int n) 形参列表， 表示当前有一个形参 n, 可以接收用户输入public void cal02(int n) {//循环完成int res = 0;for(int i = 1; i <= n; i++) {res += i;}System.out.println("cal02 方法 计算结果=" + res);}//添加 getSum 成员方法,可以计算两个数的和//老韩解读//1. public 表示方法是公开的//2. int :表示方法执行后，返回一个 int 值//3. getSum 方法名//4. (int num1, int num2) 形参列表，2 个形参，可以接收用户传入的两个数//5. return res; 表示把 res 的值， 返回public int getSum(int num1, int num2) {int res = num1 + num2;return res;}
3. 方法的调用机制原理：(重要!-示意图!!!)
4. 成员方法的好处
提高代码的复用性可以将实现的细节封装起来，然后供其他用户来调用即可5. 成员方法的定义
访问修饰符 返回数据类型 方法名（形参列表…） {//方法体
语句；
return 返回值;
}
形参列表：表示成员方法输入 cal(int n) ， getSum(int num1, int num2)返回数据类型：表示成员方法输出, void 表示没有返回值方法主体：表示为了实现某一功能代码块return 语句不是必须的。
6. 注意事项和使用细节
public class MethodDetail {public static void main(String[] args) {AA a = new AA();int[] res = a.getSumAndSub(1, 4);System.out.println("和=" + res[0]);System.out.println("差=" + res[1]);//细节: 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型 的参数byte b1 = 1;byte b2 = 2;a.getSumAndSub(b1, b2);//byte -> int//a.getSumAndSub(1.1, 1.8);//double ->int(×)//细节: 实参和形参的类型要一致或兼容、个数、顺序必须一致//a.getSumAndSub(100);//× 个数不一致a.f3("tom", 10); //ok//a.f3(100, "jack"); // 实际参数和形式参数顺序不对}}class AA {//细节: 方法不能嵌套定义public void f4() {//错误// public void f5() {// }}public void f3(String str, int n) {}//1. 一个方法最多有一个返回值 [思考，如何返回多个结果 返回数组 ]public int[] getSumAndSub(int n1, int n2) {int[] resArr = new int[2]; //resArr[0] = n1 + n2;resArr[1] = n1 - n2;return resArr;}//2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)// 具体看 getSumAndSub////3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值;// 而且要求返回值类型必须和 return 的值类型一致或兼容public double f1() {double d1 = 1.1 * 3;int n = 100;return n; // int ->double//return d1; //ok? double -> int}//如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;//老韩提示：在实际工作中，我们的方法都是为了完成某个功能，所以方法名要有一定含义//，最好是见名知意public void f2() {System.out.println("hello1");System.out.println("hello1");System.out.println("hello1");int n = 10;//return ;}}
访问修饰符 (作用是控制 方法使用的范围)
如果不写默认访问，[有四种: public, protected, 默认, private], 具体在后面说
7. 返回数据类型
一个方法最多有一个返回值 [思考，如何返回多个结果 返回数组 ]返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容如果方法是 void，则方法体中可以没有 return 语句，或者 只写 return ;
8. 方法名
遵循驼峰命名法，最好见名知义，表达出该功能的意思即可, 比如 得到两个数的和 getSum, 开发中按照规范
一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开,比如getSum(int n1,int n2)参数类型可以为任意类型，包含基本类型或引用类型，比如 printArr(int[]0] map)调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数!【getSum】方法定义时的参数称为形式参数，简称形参;方法调用时的传入参数称为实际参数，简称实参,实参和形参的类型要一致或兼容、个数、顺序必须一致![演示]
9. 方法体
里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法!即:方法不能嵌套定义。
10. 方法调用细节说明
同一个类中的方法调用:直接调用即可。比如print(参数);案例演示:A类sayOk调用print(）跨类中的方法A类调用B类方法:需要通过对象名调用。比如对象名.方法名(参数);案例演示:B类sayHello调用 print()特别说明一下:跨类的方法调用和方法的访问修饰符相关，先暂时这么提一下,后面我们讲到访问修饰符时,还要再细说。public class MethodDetail02 {//编写一个 main 方法public static void main(String[] args) {A a = new A();//a.sayOk();a.m1();}}class A {//同一个类中的方法调用：直接调用即可//public void print(int n) {System.out.println("print()方法被调用 n=" + n);}public void sayOk() {//sayOk 调用 print(直接调用即可)print(10);System.out.println("继续执行 sayOK()~~~");}//跨类中的方法 A 类调用 B 类方法：需要通过对象名调用public void m1() {//创建 B 对象, 然后在调用方法即可System.out.println("m1() 方法被调用");B b = new B();b.hi();System.out.println("m1() 继续执行:)");}}class B {public void hi() {System.out.println("B 类中的 hi()被执行");}}
11. 类定义的完善
三、成员方法传参机制(非常非常重要)
方法的传参机制对我们今后的编程非常重要，一定要搞的清清楚楚明明白白。我们通过案例来学习
1. 基本数据类型的传参机制
public class MethodParameter01 {//编写一个 main 方法public static void main(String[] args) {int a = 10;int b = 20;//创建 AA 对象 名字 objAA obj = new AA();obj.swap(a, b); //调用 swapSystem.out.println("main 方法 a=" + a + " b=" + b);//a=10 b=20}}
2. 引用数据类型的传参机制
B 类中编写一个方法 test100，可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化？会变化
B 类中编写一个方法 test200，可以接收一个 Person(age,sal)对象，在方法中修改该对象属性，看看原来的对象是否变化
public class MethodParameter02 {//编写一个 main 方法public static void main(String[] args) {//测试B b = new B();// int[] arr = {1, 2, 3};// b.test100(arr);//调用方法// System.out.println(" main 的 arr 数组 ");// //遍历数组// for(int i = 0; i < arr.length; i++) {// System.out.print(arr[i] + "\t");// }// System.out.println();//测试Person p = new Person();p.name = "jack";p.age = 10;b.test200(p);//测试题, 如果 test200 执行的是 p = null ,下面的结果是 10//测试题, 如果 test200 执行的是 p = new Person();..., 下面输出的是 10System.out.println("main 的 p.age=" + p.age);//10000}}
class Person {String name;int age;}class B {public void test200(Person p) {//p.age = 10000; //修改对象属性//思考p = new Person();p.name = "tom";p.age = 99;//思考//p = null;}//B 类中编写一个方法 test100，//可以接收一个数组，在方法中修改该数组，看看原来的数组是否变化public void test100(int[] arr) {arr[0] = 200;//修改元素//遍历数组System.out.println(" test100 的 arr 数组 ");for(int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}System.out.println();}}
结论及示意图：
引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！
四、方法重载(OverLoad)
1. 基本介绍
java 中允许同一个类中，多个同名方法的存在，但要求 形参列表不一致！
比如：System.out.println(); out 是 PrintStream 类型
2. 重载的好处
减轻了起名的麻烦减轻了记名的麻烦3. 快速入门案例
案例：类：MyCalculator 方法：calculate
calculate(int n1, int n2) //两个整数的和calculate(int n1, double n2) //一个整数，一个 double 的和calculate(double n2, int n1)//一个 double ,一个 Int 和calculate(int n1, int n2,int n3)//三个 int
public class OverLoad01 {//编写一个 main 方法public static void main(String[] args) {// System.out.println(100);// System.out.println("hello,world");// System.out.println('h');// System.out.println(1.1);// System.out.println(true);//MyCalculator mc = new MyCalculator();System.out.println(mc.calculate(1, 2));System.out.println(mc.calculate(1.1, 2));System.out.println(mc.calculate(1, 2.1));}}class MyCalculator {//下面的四个 calculate 方法构成了重载//两个整数的和public int calculate(int n1, int n2) {System.out.println("calculate(int n1, int n2) 被调用");return n1 + n2;}//没有构成方法重载, 仍然是错误的，因为是方法的重复定义// public void calculate(int n1, int n2) {// System.out.println("calculate(int n1, int n2) 被调用");// int res = n1 + n2;// }//看看下面是否构成重载, 没有构成，而是方法的重复定义,就错了// public int calculate(int a1, int a2) {// System.out.println("calculate(int n1, int n2) 被调用");// return a1 + a2;// }//一个整数，一个 double 的和public double calculate(int n1, double n2) {return n1 + n2;}//一个 double ,一个 Int 和public double calculate(double n1, int n2) {System.out.println("calculate(double n1, int n2) 被调用..");return n1 + n2;}//三个 int 的和public int calculate(int n1, int n2,int n3) {return n1 + n2 + n2;}}
4. 注意事项和使用细节
方法名∶必须相同形参列表:必须不同(形参类型或个数或顺序，至少有一样不同，参数名无要求)返回类型:无要求五、可变参数
1. 基本概念
java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。
就可以通过可变参数实现
2. 基本语法
访问修饰符 返回类型 方法名(数据类型… 形参名) {
}
3. 快速入门案例(VarParameter01.java)
看一个案例 类 HspMethod，方法 sum 【可以计算 2 个数的和，3 个数的和 ， 4. 5， 。。】
public class VarParameter01 {//编写一个 main 方法public static void main(String[] args) {HspMethod m = new HspMethod();System.out.println(m.sum(1, 5, 100)); //106System.out.println(m.sum(1,19)); //20}}class HspMethod {//可以计算 2 个数的和，3 个数的和 ， 4. 5， 。。//可以使用方法重载// public int sum(int n1, int n2) {//2 个数的和// return n1 + n2;// }// public int sum(int n1, int n2, int n3) {//3 个数的和// return n1 + n2 + n3;// }// public int sum(int n1, int n2, int n3, int n4) {//4 个数的和// return n1 + n2 + n3 + n4;// }//..... //上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化//解读//1. int... 表示接受的是可变参数，类型是 int ,即可以接收多个 int(0-多)//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组//3. 遍历 nums 求和即可public int sum(int... nums) {//System.out.println("接收的参数个数=" + nums.length);int res = 0;for(int i = 0; i < nums.length; i++) {res += nums[i];}return res;}}
4. 注意事项和使用细节
可变参数的实参可以为0个或任意多个。可变参数的实参可以为数组。可变参数的本质就是数组.可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后一个形参列表中只能出现一个可变参数public class VarParameterDetail {//编写一个 main 方法public static void main(String[] args) {//细节: 可变参数的实参可以为数组int[] arr = {1, 2, 3};T t1 = new T();t1.f1(arr);}}class T {public void f1(int... nums) {System.out.println("长度=" + nums.length);}//细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后public void f2(String str, double... nums) {}//细节: 一个形参列表中只能出现一个可变参数//下面的写法是错的. // public void f3(int... nums1, double... nums2) {// }}
六、作用域
1. 基本使用
在java编程中，主要的变量就是属性(成员变量)和局部变量。我们说的局部变量一般是指在成员方法中定义的变量。【举例Cat类: cry)java中作用域的分类全局变量:也就是属性，作用域为整个类体Cat类:cry eat等方法使用属性【举例)】
局部变量:也就是除了属性之外的其他变量，作用域为定义它的代码块中!全局变量(属性)可以不赋值，直接使用，因为有默认值，局部变量必须赋值后,才能使用，以为没有默认值【举例】
public class VarScope {//编写一个 main 方法public static void main(String[] args) {}}class Cat {//全局变量：也就是属性，作用域为整个类体 Cat 类：cry eat 等方法使用属性//属性在定义时，可以直接赋值int age = 10; //指定的值是 10//全局变量(属性)可以不赋值，直接使用，因为有默认值，double weight; //默认值是 0.0public void hi() {//局部变量必须赋值后，才能使用，因为没有默认值int num = 1;String address = "北京的猫";System.out.println("num=" + num);System.out.println("address=" + address);System.out.println("weight=" + weight);//属性}public void cry() {//1. 局部变量一般是指在成员方法中定义的变量//2. n 和 name 就是局部变量//3. n 和 name 的作用域在 cry 方法中int n = 10;String name = "jack";System.out.println("在 cry 中使用属性 age=" + age);}public void eat() {System.out.println("在 eat 中使用属性 age=" + age);//System.out.println("在 eat 中使用 cry 的变量 name=" + name);//错误}}
2. 注意事项和细节使用
属性和局部变量可以重名，访问时遵循就近原则。在同一个作用域中，比如在同一个成员方法中,两个局部变量，不能重名。[举例]属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。作用域范围不同全局变量/属性:可以被本类使用，或其他类使用(通过对象调用)局部变量:只能在本类中对应的方法中使用修饰符不同
全局变量/属性可以加修饰符
局部变量不可以加修饰符
public class VarScopeDetail {//编写一个 main 方法public static void main(String[] args) {Person p1 = new Person();/*属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中*///p1.say();//当执行 say 方法时，say 方法的局部变量比如 name,会创建，当 say 执行完毕后//name 局部变量就销毁,但是属性(全局变量)仍然可以使用//T t1 = new T();t1.test(); //第 1 种跨类访问对象属性的方式t1.test2(p1);//第 2 种跨类访问对象属性的方式}}class T {//全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)public void test() {Person p1 = new Person();System.out.println(p1.name);//jack}public void test2(Person p) {System.out.println(p.name);//jack}}class Person {//细节: 属性可以加修饰符(public protected private..)// 局部变量不能加修饰符public int age = 20;String name = "jack";public void say() {//细节 属性和局部变量可以重名，访问时遵循就近原则String name = "king";System.out.println("say() name=" + name);}public void hi() {String address = "北京";//String address = "上海";//错误,重复定义变量String name = "hsp";//可以}}
七、构造方法/构造器
1. 看一个需求
我们来看一个需求：前面我们在创建人类的对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如
果现在我要求，在创建人类的对象时，就直接指定这个对象的年龄和姓名，该怎么做? 这时就可以使用构造器。
2. 基本语法
[修饰符] 方法名(形参列表){
方法体;
}
说明：
构造器的修饰符可以默认， 也可以是 public protected private构造器没有返回值方法名 和类名字必须一样参数列表 和 成员方法一样的规则构造器的调用, 由系统完成
3. 基本介绍
构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：
方法名和类名相同没有返回值在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。
4. 快速入门
现在我们就用构造方法来完成刚才提出的问题:在创建人类的对象时，就直接指定这个对象的年龄和姓名
public class Constructor01 {//编写一个 main 方法public static void main(String[] args) {//当我们 new 一个对象时，直接通过构造器指定名字和年龄Person p1 = new Person("smith", 80);System.out.println("p1 的信息如下");System.out.println("p1 对象 name=" + p1.name);//smithSystem.out.println("p1 对象 age=" + p1.age);//80}}//在创建人类的对象时，就直接指定这个对象的年龄和姓名//class Person {String name;int age;//构造器//老韩解读//1. 构造器没有返回值, 也不能写 void//2. 构造器的名称和类 Person 一样//3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样public Person(String pName, int pAge) {System.out.println("构造器被调用~~ 完成对象的属性初始化");name = pName;age = pAge;}}
5. 注意事项和使用细节
一个类可以定义多个不同的构造器,即构造器重载比如:我们可以再给Person类定义一个构造器,用来创建对象的时候,只指定人名.不需要指定年龄构造器名和类名要相同构造器没有返回值构造器是完成对象的初始化.并不是创建对象在创建对象时,系统自动的调用该类的构造方法如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)，比如Dog 00,使用javap指令反编译看看一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器,除非显式的定义一下,即:Dog00写(这点很重要)
public class ConstructorDetail {//编写一个 main 方法public static void main(String[] args) {Person p1 = new Person("king", 40);//第 1 个构造器Person p2 = new Person("tom");//第 2 个构造器Dog dog1 = new Dog();//使用的是默认的无参构造器}}class Dog {//如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)//使用 javap 指令 反编译看看/*默认构造器Dog() {}*///一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，//除非显式的定义一下,即: Dog(){} 写 (这点很重要)//public Dog(String dName) {//... }Dog() {//显式的定义一下 无参构造器}}class Person {String name;int age;//默认 0//第 1 个构造器public Person(String pName, int pAge) {name = pName;age = pAge;}//第 2 个构造器, 只指定人名，不需要指定年龄public Person(String pName) {name = pName;}}}
八、对象创建的流程分析
九、this 关键字
1. 先看一段代码,并分析问题
public class This01 {//编写一个 main 方法public static void main(String[] args) {Dog dog1 = new Dog("大壮", 3);System.out.println("dog1 的 hashcode=" + dog1.hashCode());//dog1 调用了 info()方法dog1.info();System.out.println("============");Dog dog2 = new Dog("大黄", 2);System.out.println("dog2 的 hashcode=" + dog2.hashCode());dog2.info();}}class Dog{//类String name;int age;// public Dog(String dName, int dAge){//构造器// name = dName;// age = dAge;// }//如果我们构造器的形参，能够直接写成属性名，就更好了//但是出现了一个问题，根据变量的作用域原则//构造器的 name 是局部变量，而不是属性//构造器的 age 是局部变量，而不是属性//==> 引出 this 关键字来解决public Dog(String name, int age){//构造器//this.name 就是当前对象的属性 namethis.name = name;//this.age 就是当前对象的属性 agethis.age = age;System.out.println("this.hashCode=" + this.hashCode());}public void info(){//成员方法,输出属性 x 信息System.out.println("this.hashCode=" + this.hashCode());System.out.println(name + "\t" + age + "\t");}}
