当前位置：首页 > news >正文

Java-面向对象编程(基础部分)

news 2025/7/12 18:48:38

类和对象的区别和联系

类：类是封装对象的属性和行为的载体，在Java语言中对象的属性以成员变量的形式存在，而对象的方法以成员方法的形式存在。

对象：Java是面向对象的程序设计语言，对象是由类抽象出来的，所有的问题都是通过对象来处理，对象可以操作类的基本属性和方法解决相应的问题。

联系：类是对象的抽象，而对象时类的具体实例。

类与对象的关系示意图

类和对象的区别和联系

1) 类是抽象的，概念的，代表一类事物,比如人类,猫类.., 即它是数据类型.
2) 对象是具体的，实际的，代表一个具体事物, 即是实例.
3) 类是对象的模板，对象是类的一个个体，对应一个实例

对象在内存中存在形式(重要的)必须搞清楚。

属性/成员变量/字段

从概念或叫法上看：成员变量 = 属性 =field(字段) （即成员变量是用来表示属性的，授课中，统一叫属性
属性是类的一个组成部分，可以时基本数据类型，也可以是引用类型（对象，数组）

细节说明

1.属性的定义语法与变量相同，但是增加了访问修饰符
（控制属性的访问范围，共4种 public protected 默认 private）
格式：访问修饰符属性类型属性名
2.属性可以定义任意类型，包含基本类型或引用类型
3.属性如果不赋值，有默认值，规则和数组一致
具体说:int 0，short 0,byte 0,long 0,
float 0.0,double 0.0，char \u0000， boolean false，String null

public class PropertiesDetail{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 null// System.out.println("当前这个人的信息为");System.out.print("age=" + p1.age + "name=" + p1.name + "sal=" + p1.sal + "isPass" + p1.isPass);}
}
class Person{int age;String name;double sal;boolean isPass;
}

如何创建对象

1) 先声明再创建

Cat cat ; //声明对象 cat

cat = new Cat(); //创建

2) 直接创建

Cat cat = new Cat();

如何访问属性

基本语法对象名.属性名; 案例演示赋值和输出 cat.name ; cat.age; cat.color;

类和对象的内存分配机制(重要)

我们定义一个人类(Person)(包括名字,年龄)。 (Object03.java)

类和对象的内存分配机制

Java内存的结构分析

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

成员方法

基本介绍

在某些情况下，我们要需要定义成员方法(简称方法)。比如人类:除了有一些属性外(年龄，姓名..),我们人类还有一些行为比如:可以说话、跑步..,通过学习，还可以做算术题。这时就要用成员方法才能完成。现在要求对Person类完善。

成员方法快速入门

1）添加 speak 成员方法,输出 “我是一个好人”
2）添加 cal01 成员方法,可以计算从 1+..+1000 的结果
3）添加 cal02 成员方法,该方法可以接收一个数 n，计算从 1+..+n 的结果
4）添加 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;}
}

方法的调用机制原理：(重要!）

提示：画出程序执行过程[getSum]+说明

成员方法的好处

1）提高代码的复用性

2）可以将实现的细节封装起来，然后供其他用户来调用即可

成员方法的定义

访问修饰符 返回数据类型 方法名（形参列表..） {//方法体语句；return 返回值;
}

1）形参列表：表示成员方法输入 cal(int n) ， getSum(int num1, int num2)
2）返回数据类型：表示成员方法输出, void 表示没有返回值
3）方法主体：表示为了实现某一功能代码块
4）return 语句不是必须的。

注意事项和使用细节

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], 具体在后面说

返回数据类型

1）一个方法最多有一个返回值 [思考，如何返回多个结果 -> 返回数组 ]
2）返回类型可以为任意类型，包含基本类型或引用类型(数组，对象)
3）如果方法要求有返回数据类型，则方法体中最后的执行语句必须为 return 值; 而且要求返回值类型必须和 return 的值类型一致或兼容
4）如果方法是 void，则方法体中可以没有 return 语句，或者只写 return ;

方法名

遵循驼峰命名法，最好见名知义，表达出该功能的意思即可, 比如得到两个数的和 getSum, 开发中按照规范

形参列表

一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开,比如 getsum(int n1,int n2)
参数类型可以为任意类型，包含基本类型或引用类型，比如printArr(int[] [] map)
调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数!(先精准匹配，再类型转换)【getsum】
方法定义时的参数称为形式参数，简称形参；方法调用时的传入参数称为实际参数，简称实参，实参和形参的类型要一致或兼容、个数、顺序必须一致![演示]

方法体

里面写完成功能的具体的语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法!即:方法不能嵌套定义。[演示]

方法调用细节说明(!!!)

同一个类中的方法调用:直接调用即可。比如 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()被执行");}
}

成员方法传参机制(非常非常重要)

基本数据类型的传参机制

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); //调用swap
System.out.println("main方法 a=" + a + " b=" + b);//a=10 b=20}
}

class AA {public void swap(int a,int b){System.out.println("\na和b交换前的值\na=" + a + "\tb=" + b);//a=10 b=20//完成了 a 和 b的交换int tmp = a;a = b;b = tmp;System.out.println("\na和b交换后的值\na=" + a + "\tb=" + b);//a=20 b=10}
}

引用数据类型的传参机制

1）看一个案例

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();//200,2,3
//测试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();}
}

结论及示意图 引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参！

3) 在看一个案例，下面的方法会对原来的对象有影响吗？

p=null 和 p=new Person(); 对应示意图

成员方法返回类型是引用类型应用实例

1) 编写类MyTools类，编写一个方法可以打印二维数组的数据。

2) 编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象。克隆对象，注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同

public class MethodExercise02 { 
//编写一个main方法public static void main(String[] args) {Person p = new Person();p.name = "milan";p.age = 100;//创建toolsMyTools 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);//这里老师提示： 可以同 对象比较看看是否为同一个对象System.out.println(p == p2);//false}
}

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.namep2.age = p.age; //把原来对象的年龄赋给p2.agereturn p2;}
}

方法递归调用(非常非常重要，比较难)

基本介绍 简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁

递归能解决什么问题?

1. 各种数学问题如: 8皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子的问题(google编程大赛)[简单演示]
2.各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等.
3.将用栈解决的问题-->递归代码比较简洁

递归举例

列举两个小案例,来帮助大家理解递归调用机制
1）打印问题
2）阶乘问题

public class Recursion01 { 
//编写一个main方法public static void main(String[] args) {
T t1 = new T();t1.test(4);//输出什么？ n=2 n=3 n=4int res = t1.factorial(5); System.out.println("5的阶乘 res =" + res);}
}

class T {//分析public  void test(int n) {if (n > 2) {test(n - 1);} System.out.println("n=" + n);}
//factorial 阶乘//入口和出口public  int factorial(int n) {if (n == 1) {return 1;} else {return factorial(n - 1) * n;}}

}

递归重要规则

执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
方法的局部变量是独立的，不会相互影响,比如n变量
如果方法中使用的是引用类型变量(比如数组，对象)，就会共享该引用类型的数据
递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了;)
当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

方法重载(OverLoad)

基本介绍

java 中允许同一个类中，多个同名方法的存在，但要求形参列表不一致！

比如：System.out.println(); out 是 PrintStream 类型

重载的好处

1）减轻了起名的麻烦

2）减轻了记名的麻烦

快速入门案例

案例：类：MyCalculator 方法：calculate
1）calculate(int n1, int n2) //两个整数的和
2）calculate(int n1, double n2) //一个整数，一个 double 的和
3）calculate(double n2, int n1)//一个 double ,一个 Int 和
4）calculate(int n1, int n2,int n3)//三个 int 的和

public class OverLoad01 { 
//编写一个main方法public static void main(String[] args) {// 比如：System.out.println();     out 是 PrintStream 类型// 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;}

}

注意事项和使用细节

1）方法名：必须相同

2）形参列表：必须不同 (形参类型或个数或顺序，至少有一样不同，参数名无要求)

3）返回类型:无要求

可变参数

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

基本语法

访问修饰符 返回类型 方法名(数据类型... 形参名) {
}

快速入门案例

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;}
}

注意事项和使用细节

1）可变参数的实参可以为0个或任意多个。

2）可变参数的实参可以为数组。

3）可变参数的本质就是数组.

4）可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后

5）个形参列表中只能出现一个可变参数

代码

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) {// }
}

课堂练习

有三个方法，分别实现返回姓名和两门课成绩(总分)，返回姓名和三门课成绩(总分)，返回姓名和五门课成绩(总分)。封装成一个可变参数的方法
类名HspMethod方法名showScore

public class VarParameterExercise { 
//编写一个main方法public static void main(String[] args) {HspMethod hm = new HspMethod();System.out.println(hm.showScore("milan" , 90.1, 80.0 ));System.out.println(hm.showScore("terry" , 90.1, 80.0,10,30.5,70 ));}
}

class HspMethod  {
/*有三个方法，分别实现返回姓名和两门课成绩(总分)，返回姓名和三门课成绩(总分)，返回姓名和五门课成绩（总分）。封装成一个可变参数的方法*///分析1. 方法名 showScore  2. 形参(String ,double... ) 3. 返回String//听课小伙伴，老师要求必须自己动手写public String  showScore(String name ,double... scores ) {
double totalScore = 0;for(int i = 0; i < scores.length; i++) {totalScore += scores[i];}return name + " 有 " +scores.length + "门课的成绩总分为=" + totalScore;}}

作用域

基本使用

面向对象中，变量作用域是非常重要知识点，相对来说不是特别好理解，请大家认真思考，要求深刻掌握变量作用域。

在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.0
public 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);//错误}
}

注意事项和细节使用

属性和局部变量可以重名，访问时遵循就近原则。
在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。[举例]
属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。
局部变量，生命周期较短，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁即在一次方法调用过程中。
作用域范围不同
全局变量/属性：可以被本类使用，或其他类使用(通过对象调用)
局部变量:只能在本类中对应的方法中使用
修饰符不同
全局变量/属性可以加修饰符
局部变量不可以加修饰符

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）构造器的修饰符可以默认，也可以是 public protected private
2）构造器没有返回值
3）方法名和类名字必须一样
4）参数列表和成员方法一样的规则
5）构造器的调用, 由系统完成

基本介绍

构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

1）方法名和类名相同
2）没有返回值
3）在创建对象时，系统会自动的调用该类的构造器完成对象的初始化。

注意事项和使用细节

一个类可以定义多个不同的构造器，即构造器重载比如:我们可以再给Person类定义一个构造器,用来创建对象的时候,只指定人名不需要指定年龄
构造器名和类名要相同
构造器没有返回值
构造器是完成对象的初始化,并不是创建对象
在创建对象时,系统自动的调用该类的构造方法
如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)，比如 Dog (){},使用javap指令反编译看看
一旦定义了自己的构造器,默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下,即:Dog()){}写(这点很重要

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 关键字

什么是this?

在编程中，this 关键字是一个特殊的标识符，它被自动定义在函数和方法的执行上下文中。this 的值通常指向调用该函数的对象，也就是函数运行时所处的对象上下文。

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");}
}

深入理解this

为了进一步理解this,我们再看一个案例(This01.java)

this 的注意事项和使用细节

ThisDetail.java

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

this的课堂案例

TestPerson.java
定义Person类，里面有name、age属性，并提供compareTo比较方法，用于判断是否和另一个人相等，提供测试类TestPerson 用于测试,名字和年龄完全一样，就返回true,否则返回false

public class TestPerson { 
//编写一个main方法public static void main(String[] args) {
Person p1 = new Person("mary", 20);Person p2 = new Person("mary", 20);
System.out.println("p1和p2比较的结果=" + p1.compareTo(p2));}
}

/*
定义 Person 类，里面有 name、age 属性，并提供 compareTo 比较方法，用于判断是否和另一个人相等,名字和年龄完全一样，就返回 true, 否则返回 false
*/
class Person {String name;int age;//构造器public Person(String name, int age) {this.name = name;this.age = age;}//compareTo比较方法public boolean compareTo(Person p) {//名字和年龄完全一样// if(this.name.equals(p.name) && this.age == p.age) {//  return true;// } else {//  return false;// }return this.name.equals(p.name) && this.age == p.age;}
}

类和对象的区别和联系

类与对象的关系示意图

对象在内存中存在形式(重要的)必须搞清楚。

属性/成员变量/字段

如何创建对象

如何访问属性

类和对象的内存分配机制(重要)

类和对象的内存分配机制

成员方法

基本介绍

成员方法快速入门

方法的调用机制原理：(重要!）

成员方法的好处

成员方法的定义

注意事项和使用细节

成员方法传参机制(非常非常重要)

基本数据类型的传参机制

引用数据类型的传参机制

成员方法返回类型是引用类型应用实例

方法递归调用(非常非常重要，比较难)

递归能解决什么问题?

递归举例

递归重要规则

方法重载(OverLoad)

基本介绍

重载的好处

快速入门案例

注意事项和使用细节

可变参数

基本语法

快速入门案例

注意事项和使用细节

课堂练习

作用域

基本使用

注意事项和细节使用

构造方法/构造器

基本语法

基本介绍

注意事项和使用细节

对象创建的流程分析

this 关键字

什么是this?

深入理解this

this 的注意事项和使用细节

this的课堂案例

相关文章：