目录
一：类与对象
1.定义
类：具有相同特征的事物的抽象描述，是抽象的、概念上的定义。
对象：实际存在的该类事物的每个个体，是具体的，因而也称为实例
2.类的内部成员
类的内部成员一、二： 成员之一：属性、成员变量、field（字段、域） 成员之二：（成员）方法、函数、method
Java 中用类 class 来描述事物也是如此。类，是一组相关
属性
和
行为
的集合，这也是类最基本的两个成员。
属性：
该类事物的状态信息。对应类中的
成员变量
• 成员变量 <=> 属性 <=> Field
行为：
该类事物要做什么操作，或者基于事物的状态能做什么。对应类中的
成
员方法
•
(成员)方法 <=> 函数 <=> Method
3.类的实例化与定义
类的实例化
等价描述：类的实例化 <=> 创建类的对象 <=> 创建类的实例
格式：类类型 对象名 = 通过new创建的对象实体
举例： Phone p1 = new Phone();
Scanner scan = new Scanner(System.in);
String str =
new String();
类的定义使用关键字：class。格式如下：[ 修饰符 ] class 类名 {属性声明 ;方法声明 ;}
[修饰符]
public：公共的
protected：受保护的
缺省（在类（class）前面没有其他权限修饰符时（即省略没有写的））
private：私有的（以后常使用的）需要使用get（传输数据）与set（设置/修改/输入数据）方法
4.面向对象实现过程
面向对象完成具体功能的操作的三步流程（非常重要）
步骤1：创建类，使用class关键字，并设计类的内部成员（属性、方法）
步骤2：创建类的对象。创建对象，使用关键字：new比如：Phone p1 = new Phone();
步骤3：通过对象，调用其内部声明的属性或方法，完成相关的功能
注：对象调用属性或方法
对象是类的一个实例，必然具备该类事物的属性和行为（即方法）。使用"对象名.属性" 或 "对象名.方法"的方式访问对象成员（包括属性和方法）
//声明 Animal 类
public class Animal { //动物类
public int legs;
public void eat() {
System.out.println("Eating.");
}
public void move() {
System.out.println("Move.");
}
}
//声明测试类
public class AnimalTest {
public static void main(String args[]) {
//创建对象
Animal xb = new Animal();
xb.legs = 4;//访问属性
System.out.println(xb.legs);
xb.eat();//访问方法
xb.move();//访问方法
}
}5代码解释
//声明 Animal 类
public class Animal { //动物类
public int legs;
public void eat() {
System.out.println("Eating.");
}
public void move() {
System.out.println("Move.");
}
}
//声明测试类
public class AnimalTest {
public static void main(String args[]) {
//创建对象
Animal xb = new Animal();
xb.legs = 4;//访问属性
System.out.println(xb.legs);
xb.eat();//访问方法
xb.move();//访问方法
}
}分析：
以上代码中
类：
//声明 Animal 类
public class Animal { //动物类
}属性：
public int legs;方法：
public void eat() {
System.out.println("Eating.");
}
public void move() {
System.out.println("Move.");
}实例化
Animal xb = new Animal();
xb.legs = 4;//访问属性
System.out.println(xb.legs);
xb.eat();//访问方法
xb.move();//访问方法
图示理解：
6.超纲知识点
匿名对象 (anonymous object)我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。– 如：new Person().shout();使用情况– 如果一个对象只需要进行一次方法调用，那么就可以使用匿名对象。– 我们经常将匿名对象作为实参传递给一个方法调用。
7.代码总结
public class Phone {
//属性
String name;//品牌
double price;//价格
//方法
public void call(){
System.out.println("手机能够拨打电话");
}
public void sendMessage(String message){
System.out.println("发送信息：" + message);
}
public void playGame(){
System.out.println("手机可以玩游戏");
}
}
public class PhoneTest { //是Phone类的测试类
public static void main(String[] args) {
//复习：数据类型 变量名 = 变量值
// Scanner scann = new Scanner(System.in);
//创建Phone的对象
Phone p1 = new Phone();
//通过Phone的对象，调用其内部声明的属性或方法
//格式："对象.属性" 或 "对象.方法"
p1.name = "huawei mate50";
p1.price = 6999;
System.out.println("name = " + p1.name + ", price = " + p1.price);
//调用方法
p1.call();
p1.sendMessage("XXX");
p1.playGame();二.对象的内存解析
1.JVM 内存结构划分（了解）
堆（Heap）：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。栈（Stack）：是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。方法区（Method Area）：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据
2.栈.堆.方法区解释
- 栈 ( stack ): 方法内定义的变量，存储在栈中。- 堆 ( heap ) : new 出来的结构（比如：数组实体、对象的实体）。包括对象中的属性- 方法区 ( method area ) : 存放类的模板。比如： Person 类的模板
创建了 Person 类的两个对象Person p1 = new Person ();Person p2 = new Person ();说明：创建类的多个对象时，每个对象在堆空间中有一个对象实体。每个对象实体中保存着一份类的属性。如果修改某一个对象的某属性值时，不会影响其他对象此属性的值。p1 . age = 10 ;p2 . age = 20 ;p1 . age = 30 ;System . out . println ( p2 . age ); //20强调 2 ：声明类的两个变量Person p1 = new Person ();Person p3 = p1 ;说明：此时的 p1 ， p3 两个变量指向了堆空间中的同一个对象实体。（或 p1 , p3 保存的地址值相同）如果通过其中某一个对象变量修改对象的属性时，会影响另一个对象变量此属性的值。p1 . age = 10 ;p3 . age = 20 ;System . out . println ( p1 . age ); //20
参考以下图片解释
3. 面试题
面试题：对象名中存储的是什么呢？答：对象地址
代码解释
public class StudentTest{
public static void main(String[] args){
System.out.println(new Student());//Student@7852e922
Student stu = new Student();
System.out.println(stu);//Student@4e25154f
int[] arr = new int[5];
System.out.println(arr);//[I@70dea4e
}
}
三类的成员之一：属性
1.变量的分类：
1. 变量的分类：- 角度一：按照数据类型来分：基本数据类型（ 8种）、引用数据类型（数组、类、接口、枚 举、注解、记录）- 角度二：按照变量在类中声明的位置的不同：成员变量（或属性）、局部变量（方法内、方法形参、构造器内、构造器形参、代码块内等）
2. 属性的几个称谓
2. 属性的几个称谓：成员变量、属性、field（字段、域）
3. 区分成员变量与 局部变量
3.1 相同点：> 变量声明的格式相同：数据类型 变量名 = 变量值> 变量都有其有效的作用域。出了作用域，就失效了。> 变量必须先声明，后赋值，再使用。3.2 不同点：① 类中声明的位置的不同：属性：声明在类内，方法外的变量局部变量：声明方法、构造器内部的变量② 在内存中分配的位置不同：属性：随着对象的创建，存储在堆空间中。局部变量：存储在栈空间中③ 生命周期：属性：随着对象的创建而创建，随着对象的消亡而消亡。局部变量：随着方法对应的栈帧入栈，局部变量会在栈中分配；随着方法对应的栈帧出栈，局部变量消 亡。④ 作用域：属性：在整个类的内部都是有效的局部变量：仅限于声明此局部变量所在的方法（或构造器、代码块）中⑤ 是否可以有权限修饰符进行修饰：权限修饰符：public、protected、缺省、private。（用于表明所修饰的结构可调用的范围 的大小）属性，是可以使用权限修饰符进行修饰的。局部变量，不能使用任何权限修饰符进行修饰的。⑥ 是否有默认值：(重点)属性:都有默认初始化值意味着，如果没有给属性进行显式初始化赋值，则会有默认初始化值。局部变量：都没有默认初始化值。意味着，在使用局部变量之前，必须要显式的赋值，否则报错。注意：对于方法的形参而言，在调用方法时，给此形参赋值即可
默认值
-
基本数据类型：
byte：0short：0int：0long：0Lfloat：0.0fdouble：0.0dboolean：falsechar：'\u0000'（即空字符）
-
引用类型：
类类型：null数组类型：null
-
局部变量：
- 局部变量（在方法或代码块中声明的变量）如果没有显式初始化，编译时会报错，因为局部变量必须在使用前显式初始化。
代码解释
public class DefaultValues {
byte byteVar;
short shortVar;
int intVar;
long longVar;
float floatVar;
double doubleVar;
boolean booleanVar;
char charVar;
String stringVar;
int[] intArray;
public static void main(String[] args) {
DefaultValues dv = new DefaultValues();
System.out.println("byteVar: " + dv.byteVar); // 0
System.out.println("shortVar: " + dv.shortVar); // 0
System.out.println("intVar: " + dv.intVar); // 0
System.out.println("longVar: " + dv.longVar); // 0
System.out.println("floatVar: " + dv.floatVar); // 0.0
System.out.println("doubleVar: " + dv.doubleVar); // 0.0
System.out.println("booleanVar: " + dv.booleanVar); // false
System.out.println("charVar: " + dv.charVar); // \u0000
System.out.println("stringVar: " + dv.stringVar); // null
System.out.println("intArray: " + dv.intArray); // null
}
}
四.类的成员之二：方法
1.使用方法的好处
方法的理解： ` 方法 ` 是类或对象行为特征的抽象，用来完成某个功能操作。方法的好处：实现代码重用，减少冗余，简化代码
2.方法声明的格式 (重要)
权限修饰符 [其它修饰符] 返回值类型 方法名(形参列表) [throws 异常类型]{ //方法头//方法体}注：[]中的内部不是必须的[修饰符] 返回值类型 方法名([形参列表])[throws 异常列表]{ 方法体的功能代码 }
（1）一个完整的方法 = 方法头 + 方法体。 方法头就是[修饰符] 返回值类型 方法名([形参列表])[throws 异常列表]，也称为方法签名。 （2）方法头可能包含 5 个部分 修饰符：可选的。方法的修饰符也有很多，例如：public、protected、private、static、abstract、native、final、synchronized 等 – 权限修饰符有 private、protected，缺省，public。从左往右权限越大 – 根据是否有 static，可以将方法分为静态方法和非静态方法。其中静态方法又称为类方法，非静态方法又称为实例方法。 返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者。 – 无返回值，则声明：void – 有返回值，则声明出返回值类型（可以是任意类型）。与方法体中“return返回值”搭配使用 方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意” 形参列表：表示完成方法体功能时需要外部提供的数据列表。可以包含零个，一个或多个参数。 – 无论是否有参数，()不能省略 – 如果有参数，每一个参数都要指定数据类型和参数名，多个参数之间使用逗号分隔，例如： • 一个参数： (数据类型 参数名) • 二个参数： (数据类型 1 参数 1, 数据类型 2 参数 2) – 参数的类型可以是基本数据类型、引用数据类型 （3）方法体：方法体必须有{}括起来，在{}中编写完成方法功能的代码 （4）关于方法体中 return 语句的说明： return 语句的作用是结束方法的执行，并将方法的结果返回去 如果返回值类型不是 void，方法体中必须保证一定有 return 返回值; 语句，并且要求该返回值结果的类型与声明的返回值类型一致或兼容。 如果返回值类型为 void 时，方法体中可以没有 return 语句，如果要用 return 语句提前结束方法的执行，那么 return 后面不能跟返回值，直接写 return就可以。 注意return 语句后面就不能再写其他代码了，否则会报错：Unreachable code 补充：方法的分类：按照是否有形参及返回值 补充：方法的分类：按照是否有形参及返回值 无返回值 有返回值 无形参 void 方法名(){} 返回值的类型 方法名(){} 有形参 void 方法名(形参列表){} 返回值的类型 方法名(形参列表){}
3.方法举例
– Math.random()的 random()方法 – Math.sqrt(x)的 sqrt(x)方法 – System.out.println(x)的 println(x)方法 – new Scanner(System.in).nextInt()的 nextInt()方法 – Arrays 类中的 binarySearch()方法、sort()方法、equals()方法
4.注意点
> Java 里的 方法`不能独立存在`，所有的方法必须定义在类里。> Java 中的方法不调用，不执行。每调用一次，就执行一次。> 方法内可以调用本类中的(其它)方法或属性> 方法内不能定义方法。
5.关键字：return
5.1return的作用
- 作用 1 ：结束一个方法- 作用 2 ：结束一个方法的同时，可以返回数据给方法的调用者 ( 方法声明中如果有返回值类型，则方法内需要搭配return 使用）
5.2 使用注意点：
return 后面不能声明执行语句。
6. 方法调用的内存解析：
- 形参：方法在声明时，一对 () 内声明的一个或多个形式参数，简称为形参。- 实参：方法在被调用时，实际传递给形参的变量或常量，就称为实际参数，简称实参。
实参
emp1.id = 1001;
emp1.name = "Tom";
emp1.age = 24;
emp1.salary = 7800;
形参
public void add(int i,int j){
}其中（int i,int j）是形参
五.方法的重载(overload)
5.1定义
在同一个类中， 允许存在一个以上的同名方法，只要它们的参数列表不同 。 满足这样特征的多个方法，彼此之间构成方法的重载。
总结
“ 两同一不同 ”两同：同一个类、相同的方法名一不同：参数列表不同。① 参数个数不同 ② 参数类型不同注意：方法的重载与形参的名、权限修饰符、返回值类型都没有关系
判断两个方法是相同？
方法名相同，且形参列表相同。（形参列表相同指的是参数个数和类型都相同，与形参名没关系）要求：在一个类中，允许存在多个相同名字的方法，只要他们的形参列表不同即可
5.2重载的特点
与修饰符、返回值类型无关，只看参数列表，且参数列表必须不同。
(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。
5.3练习
判断与 void show(int a,char b,double c){} 构成重载的有：a) void show ( int x , char y , double z ){} // nob) int show ( int a , double c , char b ){} // yesc) void show ( int a , double c , char b ){} // yesd) boolean show ( int c , char b ){} // yese) void show ( double c ){} // yesf) double show ( int x , char y , double z ){} // nog) void shows (){ double c } // no
六.可变个数的形参
6.1. 使用场景
在调用方法时，可能会出现方法形参的类型是确定的，但是 参数的个数不确定 。此时，我们就可以使用可变个数形参的方法
6.2.格式
( 参数类型 ... 参数名 )等价于 ( 参数类型 [] 参数名 )
举例：
//JDK 5.0 以前：采用数组形参来定义方法，传入多个同一类型变量public static void test ( int a , String [] books );//JDK5.0 ：采用可变个数形参来定义方法，传入多个同一类型变量public static void test ( int a , String ... books );
说明：
① 可变个数形参的方法在调用时， 可变的形参赋的实参的个数可以为：0个、1个或多个② 可变个数形参的方法与同一个类中，同名的多个方法之间可以构成重载③ 特例： 可变个数形参的方法与同一个类中方法名相同，且与可变个数形参的类型相同的数组参数不构成重载。④ 可变个数的形参必须声明在形参列表的最后（重要）⑤ 可变个数的形参最多在一个方法的形参列表中出现一次
6.3代码解析
public class NumberTools {
public int total(int[] nums){
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
return sum;
}
public int sum(int... nums){
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
return sum;
}
}
public class TestVarParam {
public static void main(String[] args) {
NumberTools tools = new NumberTools();
System.out.println(tools.sum());//0 个实参
System.out.println(tools.sum(5));//1 个实参
System.out.println(tools.sum(5,6,2,4));//4 个实参
System.out.println(tools.sum(new int[]{5,6,2,4}));//传入数组实参
System.out.println("------------------------------------");
System.out.println(tools.total(new int[]{}));//0 个元素的数组
System.out.println(tools.total(new int[]{5}));//1 个元素的数组
System.out.println(tools.total(new int[]{5,6,2,4}));//传入数组实参
}
}七.方法的参数传递机制
7.1复习形参和实参
形参（formal parameter） ：在定义方法时，方法名后面括号()中声明的变量称为形式参数，简称形参。实参（actual parameter）： 在调用方法时，方法名后面括号()中的使用的值/变量/表达式称为实际参数，简称实参。
7.2参数传递机制：值传递
Java 方法的参数传递方式： 值传递 。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。形参是 基本数据类型 ：将实参基本数据类型变量的“ 数据值 ”传递给形参形参是 引用数据类型 ：将实参引用数据类型变量的 “地址值 ”传递给形参
7.3代码举例
7.31地址相同
class ValueTransferTest {
public static void main(String[] args) {
//1. 基本数据类型的局部变量
int m = 10;
int n = m; //传递的是数据值
System.out.println("m = " + m + ", n = " + n);//m=10,n=10
m++;
System.out.println("m = " + m + ", n = " + n);//m=11;n=10;
//2. 引用数据类型的局部变量
//2.1 数组类型
int[] arr1 = new int[]{1, 2, 3, 4, 5};
int[] arr2 = arr1;//传递的是地址值
arr2[0] = 10;//两个地址相同
System.out.println(arr1[0]);//10
//2.2 对象类型
Order order1 = new Order();
order1.orderId = 1001;
Order order2 = order1; //传递的是地址值
order2.orderId = 1002;
System.out.println(order1.orderId);//1002
}
}
class Order {
int orderId;
}
通过地址改变形参
class ValueTransferTest1 {
public static void main(String[] args) {
ValueTransferTest1 test = new ValueTransferTest1();
//1. 对于基本数据类型的变量来说
int m = 10;
test.method1(m);
System.out.println("m = " + m);//10，形参改变，实参没有改变
//2. 对于引用数据类型的变量来说
Person p = new Person();
p.age = 10;
test.method2(p);//传输地址，使数据改变
System.out.println(p.age); //11
}
public void method1(int m) {
m++;
}
public void method2(Person p) {
p.age++;
}
}
class Person {
int age;
}
错误形式
class ValueTransferTest2 {
public static void main(String[] args) {
ValueTransferTest2 test = new ValueTransferTest2();
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);
//调用方法
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);
}
public void swap(int m, int n) {
int temp = m;
m = n;
n = temp;
}
}
通过地址改变形参
class ValueTransferTest3 {
public static void main(String[] args) {
ValueTransferTest3 test = new ValueTransferTest3();
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("m = " + data.m + ", n = " + data.n);
//操作1：
int temp = data.m;
data.m = data.n;
data.n = temp;
//操作2：
test.swap(data);
System.out.println("m = " + data.m + ", n = " + data.n);
}
public void swap(Data data) {
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
class Data {
int m;
int n;
}
八.递归方法
8.1递归方法定义
方法自己调用自己的现象就称为递归。
8.2递归的分类
直接递归、间接递归
注意
递归方法包含了一种 隐式的循环 。递归方法会 重复执行 某段代码，但这种重复执行无须循环控制。递归一定要向 已知方向 递归，否则这种递归就变成了无穷递归，停不下来，类似于 死循 环 。最终发生 栈内存溢出 。
举例 1：计算 1 ~ n 的和
public class RecursionDemo {
public static void main(String[] args) {
RecursionDemo demo = new RecursionDemo();
//计算 1~num 的和，使用递归完成
int num = 5;
// 调用求和的方法
int sum = demo.getSum(num);
// 输出结果
System.out.println(sum);
}
/*
通过递归算法实现.
参数列表:int
返回值类型: int
*/
public int getSum(int num) {
/*
num 为 1 时,方法返回 1,
相当于是方法的出口,num 总有是 1 的情况
*/
if (num == 1) {
return 1;
}
/*
num 不为 1 时,方法返回 num +(num-1)的累和
递归调用 getSum 方法
*/
return num + getSum(num - 1);
}
}
九. 关键字：package、import
9.1package
package，称为包，用于指明该文件中定义的类、接口等结构所在的包。
9.2语法格式
package 顶层包名 . 子包名 ;举例：pack1\pack2\PackageTest.java
9.3说明
• 一个源文件只能有一个声明包的 package 语句• package 语句作为 Java 源文件的第一条语句出现。若缺省该语句，则指定为无名包。• 包名，属于标识符，满足标识符命名的规则和规范（全部小写）、见名知意– 取包名时不要使用"java.xx"包• 包对应于文件系统的目录，package 语句中用 “.” 来指明包(目录)的层次，每.一次就表示一层文件目录。• 同一个包下可以声明多个结构（类、接口），但是不能定义同名的结构（类、接口）。不同的包下可以定义同名的结构（类、接口 ）
9.4包的作用
- 包可以包含类和子包，划分`项目层次`，便于管理- 帮助 管理大型软件 系统：将功能相近的类划分到同一个包中。比如： MVC 的设计模式- 解决 类命名冲突 的问题- 控制 访问权限
9.5 import关键字
9.51定义
- import : 导入import 语句来显式引入指定包下所需要的类。相当于 `import 语句告诉编译器到哪里去寻找这个类 。
9.52 语法格式
import 包名 . 类名 ;
9.53注意
- import语句，声明在包的声明和类的声明之间。- 如果需要导入多个类或接口，并列显式多个 import 语句即可- 如果使用`a.*`导入结构，表示可以导入a包下的所有的结构 。举例：可以使用 java . util . * 的方式，一次 性导入util 包下所有的类或接口。- 如果导入的类或接口是 java . lang 包下的，或者是当前包下的，则可以省略此 import 语句。- 如果已经导入 java . a 包下的类，那么如果需要使用 a 包的子包下的类的话，仍然需要导入。- 如果在代码中使用不同包下的同名的类，那么就需要使用类的全类名的方式指明调用的是哪个类。
超纲知识点
import static`组合的使用：调用指定类或接口下的静态的属性或方法
代码举例
import pack1.pack2.Test; //import pack1.pack2.*;表示引入 pack1.pack2
包中的所有结构
public class PackTest{
public static void main(String args[]){
Test t = new Test(); //Test 类在 pack1.pack2 包中定义
t.display();
}
}十.面向对象特征一：封装性(encapsulation）
10.1封装性定义
把客观事物封装成抽象概念的类，并且类可以把自己的数据和方法只向可信的类或者对象开放， 向没必要开放的类或者对象隐藏信息。
10.2实现数据封装
使用权限修饰符： public 、 protected 、 缺省 、 private
修饰符作用本类内部 本包内 其他包的子类 其他包非子类private √ × × ×缺省 √ √ × ×protected √ √ √ ×public √ √ √ √具体修饰的结构：– 外部类：public、缺省– 成员变量、成员方法、构造器、成员内部类：public、protected、缺省、private
10.3封装性的体现
成员变量/属性私有化注意：私有化类的成员变量， 提供公共的 get 和 set 方法 ，对外暴露获取和修 改属性的功能。
10.4代码演示
public class AnimalTest {
public static void main(String[] args) {
Animal animal1 = new Animal();
animal1.name = "金蟾";
//因为legs声明为private，是私有的，出了Animal类之外就不能调用了。
// animal1.legs = 4;
// animal1.legs = -4;
//只能通过setLegs()，间接的对legs属性进行赋值。
animal1.setLegs(2);
animal1.setLegs(-2);
// System.out.println("name = " + animal1.name + ", legs = " +
animal1.legs);
System.out.println("name = " + animal1.name + ", legs = " +
animal1.getLegs());
animal1.eat();
}
}
class Animal { //动物
//属性
String name; //名字
private int legs;//腿的个数
//方法
//设置legs的属性值
public void setLegs(int l) {
if (l >= 0 && l % 2 == 0) {
legs = l;
} else {
System.out.println("你输入的数据非法");
}
}
//获取legs的属性值
public int getLegs() {
return legs;
}
public void eat() {
System.out.println("动物觅食");
}
}
十一.构造器（constructor），构造方法
11.1构造器作用
new 对象，并在 new 对象的时候为实例变量赋值。
作用 1 ：搭配 new 关键字，创建类的对象作用 2 ：在创建对象的同时，可以给对象的相关属性赋值作用 3 ：在创建对象的同时，可以执行一些初始化的操作
11.2 构造器的语法格式
[ 修饰符 ] class 类名 {[ 修饰符 ] 构造器名 (){// 实例初始化代码}[ 修饰符 ] 构造器名 ( 参数列表 ){// 实例初始化代码}}
注意：
构造器名必须与它所在的类名必须相同。没有返回值，不需要返回值类型，也不需要 void。构造器的修饰符只能是权限修饰符，不能被其他任何修饰 。比如，不能被 static、final、synchronized、abstract、native 修饰，不能有 return 语句返回值。
11.3.构造器的使用说明
创建类以后，在没有显示提供任何构造器的情况下，系统会默认提供一个空参的构造器，且构造器的权限与类声明的权限相同。一旦类中显示声明了构造器，则系统不再提供默认的空参的构造器。一个类中可以声明多个构造器，彼此之间构成重载。
11.4代码演示
class Person {
//属性
String name;
int age;
//构造器
public Person() {
System.out.println("Person()....");
}
//声明其它的构造器
public Person(int a) {
age = a;
}
public Person(String n) {
name = n;
}
public Person(String n, int a) {
name = n;
age = a;
}
//方法
public void eat() {
System.out.println("人吃饭");
}
2.代码案列
public void sleep(int hour) {
System.out.println("每天睡眠" + hour + "小时");
}
}
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.eat();
Person p2 = new Person(1);
System.out.println(p2.age); //1
Scanner scan = new Scanner(System.in);
}
}11.5 类中属性（实例变量）赋值过程
11.51 在类的属性中，可以有哪些位置给属性赋值？
① 默认初始化② 显式初始化③ 构造器中初始化④ 通过"对象.属性"或"对象.方法"的方式，给属性赋值
11.52执行的先后顺序
顺序：① - ② - ③ - ④
注意
①、②、③在对象创建过程中，只执行一次。④ 是在对象创建后执行的，可以根据需求多次执行
扫一扫
498
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
