本文主要是介绍java2106 第二周总结，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

本周总结

一、switch语句的应用

键盘录入月份的值(默认int),请使用switch来完成,判断季节
（3,4,5 春季，6,7,8 夏季，9,10,11 秋季，12,1,2冬季）
代码：

//导包
import java.util.Scanner ;
class SwitchTest2{
	
	public static void main(String[] args){
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并录入数据
		System.out.println("请您输入一个月份的值:") ;
		int month = sc.nextInt() ;
		
		//使用switch语句接受数据
		switch(month){
		case 3:
		case 4:
		case 5:
			System.out.println("春季");
			break ;
		case 6:
		case 7:
		case 8:
			System.out.println("夏季");
			break ;
		case 9:
		case 10:
		case 11:
			System.out.println("秋季");
			break ;
		case 12:
        case 1:
        case 2:
			System.out.println("冬季");
			break ;
		default:
			System.out.println("对不起,您输入的月份有误.");
			break ;		
		}	
	}
}

二、循环语句

1、循环语句----for

格式

for(初始化语句；条件表达式；步长/控制体语句){
	循环体语句;
	}

执行流程

1)执行初始化化语句:给变量进行赋值
	2)满足条件:成立
	3)执行循环体语句
	4)执行步长/控制体语句
	
	再次执行2)过程,判断条件是否成立
	依次循环
	
	...
	...
	当条件表达式不成立,则for语句结束!

举例

使用for循环语句求1-10之间的和？

class demo{
public static void main(String[] args){
int temp=0;
for(int x=1;x<=10;x++){
temp=temp+x;
}
System.out.println("1-10之间的数据和是:"+sum) ;
	}
}

2、 循环语句----while

格式

while循环语句格式：
基本格式
while(判断条件语句) {
循环体语句;
}
扩展格式
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}

执行流程

1)初始化话语句进行赋值
2)条件表达式成立,
执行循环体语句
再次执行控制体语句
3)再次判断条件表达式是否成立,
…
…
当条件不成立,则while结束

举例

计算1-100的和？

public static void main(String[] args) {
//使用while循环实现
//定义一个变量,记录累加求和
int sum = 0;
//定义初始化表达式
int i = 1;
//使用while循环让初始化表达式的值变化
while(i<=100){
//累加求和
sum += i ;
//步进表达式改变变量的值
i++;
}
//打印求和的变量
System.out.println("1‐100的和是："+sum);
}

for和while的区别

1)从格式上来讲:格式不同
	for(初始化语句;条件表达式;控制体语句){
		循环体语句;
	}
	初始化语句;
	while(条件表达式){
		循环体语句;
		控制体语句;
	}
	for循环结束之后,不能在访问for中变量,for循环结束;
	变量需要被释放掉了!
	while循环可以访问
	
2)内存:for循环节省内存空间
		堆,栈内存(存储局部变量:在方法定义中/方法声明上的变量),
		方法区..(main())
		
		for循环结束,变量随着被释放掉,节省内存空间;(不能访问这个变量了.)
		while循环结束,依然可以访问这个变量,比较消耗内存空间...

3)使用场景:
	for循环:明确循环次数使用  水仙花数:100-999 (开发中:优先考虑for)
	while循环:不明确循环次数,使用

3、 死循环

//两种格式:
//1）
			for(;;){	
				循环体语句;
			}
//2）			
		while(true){
			循环体语句;
		}	

示例

class DieForWhileDemo{
	public static void main(String[] args){
		//for的死循环格式:
			for(;;){
				System.out.println("死循环...") ;
			}

		//while循环
		while(true){//恒成立
			System.out.println("死循环...") ;
		}
	}
}

4、循环语句—do_while

格式

初始化语句;
do{
	循环体语句;
	控制体语句;
}while(条件表达式) ;

扩展格式
初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);

do…while循环的特点

无条件执行一次循环体，即使我们将循环条件直接写成false，也依然会循环一次。

举例

计算1-100的和？

class DoWhileDemo{
	public static void main(String[] args){
		//1-100之间的和
		//定义一个最终结果变量
		int sum = 0 ;
		int x = 1 ;
		do{
			sum += x ;
			x ++ ;
		}while(x<=100) ;
		System.out.println("1-100之间的和是:"+sum) ;

5、for循环嵌套

概念：

一个for循环语句作为另一个for循环语句的循环

格式

for(初始化语句;条件表达式;控制体语句){
	for(初始化语句;条件表达式;控制体语句){
	}
}

举例

打印"**"形(4行5列的*)

class ForForDemo{
	public static void main(String[] args){
	for(int x = 0 ; x < 4 ; x++){ //外层循环:就是一个控制行数
			for(int y = 0 ; y < 5 ; y ++){//内层循环:控制列数
				System.out.print("*") ; //在同一行输出5个*
			}
			System.out.println() ;
		}
	}	
}	

三、跳转控制语句

1、break

break :结束中断,结束循环(不能单独使用)

使用场景：终止switch或者循环
在选择结构switch语句中
在循环语句中
离开使用场景的存在是没有意义的

使用示范

class BreakDemo{
	public static void main(String[] args){

		for(int x = 0 ; x < 10 ; x ++){ 
			//判断
			if(x == 3){
				break ;
			}
			System.out.println(x) ;//0,1,2
		}
		System.out.println("over") ;
		}
}

2、continue

continue:继续, 在循环中使用 ,
结束当前循环,立即进入下一次循环

使用示范

class ContinueDemo{
	public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
//需求:不打印第三次HelloWorld
if(i == 3){
continue;
}
System.out.println("HelloWorld"+i);
	}
}

3、return

Return关键字不是为了跳转出循环体，更常用的功能是结束一个方法，也就是退出一个方法。跳转到上层调用的方
法。

使用示范

class ReturnDemo{
	public static void main(String[] args){
		//程序:引入 return
		System.out.println("程序开始了....") ;
		for(int x = 0 ; x < 10 ; x ++){
			System.out.println("进入for循环了...") ;
			if(x==3){
				return ; //单独使用,return:结束方法的
			}
			System.out.println(x) ;//0,1,2
		}
		System.out.println("程序结束了...") ;
	}
}

return 是需要和方法相关的使用的,单独使用非常少

四、方法

概念

方法: 就是使用{}代码块包起来,并且起一个名字(见名知意)

Java中定义方法的格式:

1)有具体返回值类型的方法的定义

	固定格式
		 public static 返回值类型 方法名(参数类型1 变量名1,参数类型2 变量名2....){
				
				方法中的业务逻辑代码...
				return 结果;	 
		 }


				public: 访问权限足够大,公共的
				static: 静态修饰符(面向对象中讲)
				返回值类型:就是数据类型(目前使用的基本数据类型...)
				方法名: 见名知意 (小驼峰命名法)
				参数类型:第一个参数的数据类型
				变量名:符合 (小驼峰命名法)
				return 结束方法以及返回方法指定类型的值
				返回值 程序被return带回的结果，返回给调用者

有具体返回值类型的方法的调用:

		1)单独调用(不用它)
		2)输出调用:不建议:因为 直接输出,想使用这个结果值进行操作就不可以了
		3)赋值调用:推荐

注意事项

	1)方法和方法是平级关系,不能进行嵌套:	在一个方法中定义另一个方法不允许		
	2)在Java中,定义方法的时候形式参数必须携带数据类型!
		(Java是一个强类型语言			
		 Javascript:弱类型语言:定义函数的,参数不需要带类型）
	3)调用方法的时候,传递的实际参数不需要在携带数据类型了 
	4)定义方法的时候: 有{括号的地方不能有分号; 

举例

class FunctionDemo{
	public static void main(String[] args){
			int a = 30 ;
			int b = 20 ;
			int result = sum(a,b) ;
			System.out.println(result) ;	
	}
	public static int sum(int a,int b){//形式参数
		
			int result = a + b;//30+20
			return result ;
	}
}

2）没有具体返回值类型的方法的定义:

		针对某个功能代码块{} 没有具体的返回值类型,按照语法规定:必须有一个值
		Java提供了一个关键字:代替没有具体返回值类型 void 
	
		固定格式:
		public static void 方法名(形式参数列表){
				方法体中的内容；
		      }

举例

键盘录入一个数据a(1<=a<=9)，输出对应的nn乘法表

import java.util.Scanner;
ublic class Homework {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入a的值");
		int a = sc.nextInt();
		chengFaBiao(a);
	}
	public static void chengFaBiao(int a) {
		for (int x = 1; x <= a; x++) {
			for (int z = 1; z <= x; z++) {
				System.out.print(z + "*" + z + "=" + z * z + "\t");
			}
			System.out.println();
		}
	}
}

—方法重载

方法重载(overload) :

方法名相同,参数列表不同,与返回值无关!
参数列表不同:
1)参数个数不同
2)参数类型不同

方法重载的目的:

就是为了提高某个功能的扩展性

在有的时候:同一个方法,可以传递任何数据类型

方法重载的特点

返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法

方法的形式参数问题:

	1)如果方法的形式参数是基本数据类型,有什么特点?
		形式参数的改变不会影响实际参数!
	2)如果方法的形式参数是引用数据类型(数组),有什么特点?
	String类型:特殊的引用类型:它作为形式参数,效果和基本数据类型一致!
	形式参数的改变不影响实际参数(String本质就是常量)
	如果形式参数是数组类型(除String类型外),
		实际参数传递:传递数组对象 :形式参数的改变会直接影响实际参数

五、数组

数组概念：

就是存储多个数据的容器,必须保证容器中的数据类型一致!

数组的定义格式:

1)动态初始化

给定了数组的长度,系统默认对元素进行初始化!

格式：

		数据类型[]  数组名称   = new 数据类型[数组长度] ;
		数据类型   数组名称[]   = new 数据类型[数组长度] ;

2)静态初始化

我们给定的具体的元素,数组长度由系统确定

格式：

			数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
			数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;
	简化格式:
			数据类型[] 数组名称  = {元素1,元素2,元素3....} ;
			数据类型 数组名称[]  = {元素1,元素2,元素3....} ;

程序报错（了解）:

		编译时期异常:jvm运行java程序:检查语法  (调用者必须处理!)
		后期:IOEXception: 读写数据时
				 ParseExceptin:解析异常
				将"2021-7-13" 日期文本格式---->java.util.Date
	运行时期异常:RuntimeException
				代码逻辑不严谨或者其他业务判断导致的出现问题		
		ArrayIndexOutOfBoundsException:
				数组角标越界异常
				开发者:需要检查数组的角标是否正确!
		NullpointerException:空指针异常:
				描述:当前某个对象为null,我们还要使用对象操作,就会出现问题了			
				都是可以通过逻辑判断解决
				针对某个对象进行非空判断

静态初始化应用

将int[] arr = { 43, 65, 3, 6, 76 };进行遍历

public class work01 {

	public static void main(String[] args) {
		int[] arr = { 43, 65, 3, 6, 76 };
		System.out.println("遍历后：");
		bianLi(arr);
}
		public static void bianLi(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				System.out.println(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ",");
			}
		}
	}
}

数组高级排序------冒泡

冒泡排序思想:
两两比较,较大的值往后放,第一次比较完毕,最大值出现在最大索引处
依次这样比较,可以得到排好序的数组!

编写程序，已知数组int[] arr = {43,65,3,6,76}，
对数组—冒泡进行排序之后，然后进行遍历输出结果；

public class work01 {

	public static void main(String[] args) {
		int[] arr = { 43, 65, 3, 6, 76 };
		System.out.println("排序前：");
		bianLi(arr);
		System.out.println("遍历排序后");
		paiXu(arr);
		bianLi(arr);
	}

	public static void paiXu(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = 0; y < arr.length - 1; y++) {
				if (arr[y] > arr[y + 1]) {
					int num = arr[y];
					arr[y] = arr[y + 1];
					arr[y + 1] = num;
				}
			}
		}
	}

	public static void bianLi(int[] arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
				System.out.println(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ",");
			}
		}
	}
}

Java中的内存分配

Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，
因为每一片区域都有特定的处理数据方式和内存管理方式。

 栈： 存储局部变量
 堆 ：存储new出来的东西
 方法区：自定义的方法/jdk提供的方法
 本地方法区：（和系统相关）
  寄存器：（给CPU使用）

六、面向对象

1、引入

面向对象基于面向过程:

面向过程: (自己就是执行者)	代表:c语言
		1)需求分析
		2)定义功能代码块(方法)
		3)在main 方法调用,显示结果
					
	面向对象:代表java语言
			需要找一个对象完成一件事件:比如 :键盘录入一个数据  (jdk提供--->Scanner)
			创建键盘录入对象
			提示并录入数据
			展示结果

​2、面向对象的思想特点:

​ 1)更符号我们生活中是思想行为习惯
​ 2)让复杂的事情简单化
​ 3)我们从执行者变成了指挥者

3、 面向对象的三大特征:

封装,继承,多态

4、面向对象的设计理念:

不断的去创建对象,使用对象,指挥对象做事情! (Scanner:键盘录入)

4、类与对象的关系

类：是一组相关的属性和行为的集合
对象：是该类事物的具体体现
举例： 类 学生 对象 班长就是一个对象
类：可以理解为构造对象的一个蓝图或者模版，是抽象的概念
对象：是以类为模型创建的具体实例，是对类
的一种具体化。

5、类的定义

现实世界的事物 属性 人的身高，体重等 行为 人可以学习，吃饭等
Java中用class描述事物也是如此 成员变量 就是事物的属性 成员方法 就是事物的行为 定义类其实就是定义类的成
员(成员变量和成员方法)

例题

定义一个计算器类，提供加减乘除的功能，并进行测试(在Test测类中进行测试,可以键盘录入两个数据进行测试)
提示:计算器英文单词:Caculator
在这个类中提供 四个成员方法:加减乘除

import java.util.Scanner;

class Caculator {
	public void add(int a, int b) {
		int temp = a + b;
		System.out.println("a+b的值是：" + temp);
	}

	public void jian(int a, int b) {
		int temp = a - b;
		System.out.println("a-b的值是：" + temp);
	}

	public void cheng(int a, int b) {
		int temp = a * b;
		System.out.println("a*b的值是：" + temp);
	}

	public void chu(int a, int b) {
		int temp = a / b;
		System.out.println("a/b的值是：" + temp);
	}
}

class CaculatorDemo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请依次输入两个数");
		int a = sc.nextInt();
		int b = sc.nextInt();
		Caculator caculator = new Caculator();
		caculator.add(a, b);
		caculator.jian(a, b);
		caculator.cheng(a, b);
		caculator.chu(a, b);
	}
	
}

6、成员变量和局部变量

成员变量：

   1、成员变量定义在类中，在整个类中都可以被访问。
   2、成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。
   3、成员变量有默认初始化值。

局部变量：

  1、局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。
  2、局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。
  3、局部变量没有默认初始化值 

区别

1)在程序中的书写位置不同：

    局部变量：方法定义或方法声明上
    成员变量：在类中，成员方法外定义的变量

2）在内存中

    局部变量：在栈内存中
	成员变量：在堆内存中

3）生命周期不同

	局部变量：随着方法调用而存在，随着方法调用完毕而消失
	成员变量：随着对象的创建而存在，随着对象创建完毕之后，不会立即消失，需要等待GC（垃圾回收器）空闲时候回收掉
4）初始化不同

	局部变量：可以先定义，但是必须在使用之前赋值，否则:可能尚未初始化变量
	成员变量：可以不初始化，它存在系统默认初始化（根据类型判定）

形式参数问题

/*
	需求:访问Demo类中的show方法?
*/
//程序类
class Programmer{
	public void coding(){
		System.out.println("程序员根据需求写代码...") ;
	}
}
//定义Demo类
class Demo{
	//有一个成员方法
	public void show(Programmer programmer){//如果方法的形式参数是一个引用类型:类---就需要创建当前类对象
		programmer.coding() ;
	}
}
class Test{//测试类
	public static void main(String[] args){
		//创建Demo类对象
		Demo d = new Demo() ;
		//创建Programmer类的对象
		Programmer pro = new Programmer() ;
		
		d.show(pro) ;
		
	}
}

7、 匿名对象

概念

顾名知意:没有名字的对象，是对象的一种简化表示形式

格式

new 类名() ;

匿名对象有一个特点:可以作为参数进行传递
在开发中,匿名对象使用一次即可!
(因为没有栈内存变量指向堆内存地址,
直接是在堆内存开辟空间,使用完毕,立即被回收!)

8、封装

封装概述

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

好处：

隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。

封装原则：

将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。

封装目的:

为了保证的数据的安全性!

private关键字:

特点
	1)可以修饰成员变量,也可以修饰成员方法,但是都只能在本类访问,外界类不能够访问
	2)这些被私有修饰的成员变量,或者成员方法,可以间接通过公共方法来访问!

为了将某个类的成员属性隐藏(将属性(成员变量)“私有化”),
并为之提供公共(public)访问方式!(setXXX()/getXXX())
私有化:就是关键字"private" 只能在本类中访问

示例

class Student2{
	//成员变量私有化
	private String name ;//姓名
	private int age ; //年龄
	private String gender ;//性别
	private String hobit ; //爱好
	//成员方法
	public void study(){
		System.out.println("学习JavaEE...") ;
	}
	//玩游戏
	public String playGame(String gameName){
		return "会玩"+gameName ;
	}
	//运行
	public void sport(){
		System.out.println("喜欢踢足球...") ;
	} 
	//一些公共访问方法:给姓名,年龄,性别,爱好赋值  /还需要获取这些内容
	//给学生的姓名赋值
	public void setName(String n){ //"高圆圆"
			name = n ;//name = n = "高圆圆"
	}
	//获取学生的姓名--->返回值:String
	public String getName(){
		return name ;
	}
	//给学生的年龄赋值
	public void setAge(int a){ //41
		age = a ; //age = a = 41
	}
	//获取学生的年龄:int类型
	public int getAge(){
		return age ;
	}
	//给学生的性别赋值
	public void setGender(String g){ //"女"
		gender = g ; 	//gender = g  ="女"
	}
	//获取学生的性别:String
	public String getGender(){
		return gender ;
	}
	//给学生的爱好赋值
	public void setHobit(String h){	//"跑步"
		hobit = h ;	//hobit = h = "跑步"
	}
	//获取学生的爱好:String
	public String getHobit(){
		return hobit ;
	}	
}
//测试类
class StudentTest2{
	public static void main(String[] args){
		//创建学生类测试
		Student2 s = new Student2() ;
		//对象名.公共的成员方法名() 赋值
		s.setName("高圆圆") ;
		s.setAge(41) ;
		s.setGender("女") ;
		s.setHobit("跑步") ;
		System.out.println("当前学生的姓名是:"+
		s.getName()+",年龄是:"+s.getAge()+",性别是:"+s.getGender()+",爱好是:"+s.getHobit()) ;
	
		//其他成员方法
		s.study() ;//学习
		String str = s.playGame("lol") ;
		System.out.println(str) ;
		s.sport() ;
	}
}

this关键字

this:代表所在类的对象引用
this:就是代表当前类的对象的地址值引用!

给属性赋值的时候:局部变量隐藏了成员变量:名称都是一样的
Java此时提供关键字this:解决局部变量隐藏了成员变量

this.成员变量名 = 局部变量;

使用示例

学生事物
属性:姓名,年龄,性别
行为:学习,抽烟…
学生类进行描述学生事物—加入封装思想并加入this关键字

class Student{
	private String name ;
	private int age ;
	private String gender ;
	
	//提供公共 的setXXX()/getXXX()方法
	//赋值姓名
	public void setName(String name){
		this.name = name ;
	}
	public String getName(){
		return name ;
	}
	
	//给年龄赋值
	public void setAge(int age){
		this.age  = age ;
	}
	//获取年龄
	public int getAge(){
		return age ;
	}
	//给性别赋值
	public void setGender(String gender){
		this.gender = gender ;
	}
	//获取性别
	public String getGender(){
		return gender ;
	}
	//学生学习的成员方法
	public void study(String className){
		System.out.println("正在学习"+className) ;
	}
	//抽烟
	public void smoke(String smokeBrand){
		System.out.println("抽"+smokeBrand) ;
	}
}
//测试类
class StudentTest{
	public static void main(String[] args){
		//创建学生类对象
		Student s = new Student() ;
		//赋值setXXX
		s.setName("马三奇") ;
		s.setAge(20) ;
		s.setGender("男") ;
		System.out.println("学生的姓名是:"+s.getName()+",年龄为:"+s.getAge()+",性别为:"+s.getGender()) ;
		s.study("JavaSE之面向对象") ;
		s.smoke("小橘") ;
		
	}
}

9、构造方法

构造方法概念：

	1)构造方法名和类名一致
	2)没有具体的返回值类型
	3)连void都没有

构造方法的目的:

为了给类的成员的一些数据进行初始化

构造方法的使用注意事项:

1)当我们书写某个类中代码的时候,没有给这个类提供任何构造方法,那么系统 会默认提供一个无参构造方法	
 2)如果我们提供了有参构造方法任何一种,那么系统就不会在提供无参构造方法了
		建议:永远给出类的无参构造方法	

使用代码示例

class Phone{
	private String brand ;
	private int price ;//价格
	private String color ;
	
	public Phone(){	
	}
	//提供了带参数构造方法
	//("锤子手机",1299,"黑色"
	public Phone(String brand,int price ,String color){//局部变量
		this.brand = brand ;
		this.price = price ;
		this.color = color ;
	}
	//提供setXXX()/getXXX()方法
	public void setBrand(String brand){
		this.brand = brand ;
	}
	public String getBrand(){
		return brand ;
	}
	//给价格赋值
	public void setPrice(int price){
		this.price = price ;
	}
	public int getPrice(){
		return price ;
	}
	//给颜色赋值
	public void setColor(String color){
		this.color = color ;
	}
	public String getColor(){
		return color ;
	}
	//其他成员方法(手机事物的行为)	
}
//测试类
class ConstructorDemo2{
	public static void main(String[] args){
		//通过无参构造方法创建对象
		//方式1:无参构造方法+setXXX()/getXXX()
		Phone p = new Phone();//
		//setXXX()赋值
		p.setBrand("锤子手机") ;
		p.setPrice(1299) ;
		p.setColor("黑色") ;
		System.out.println("品牌:"+p.getBrand()+",价格:"+p.getPrice()+",颜色:"+p.getColor()) ;
		System.out.println(p) ;
		System.out.println("---------------------") ;
		//方式2:通过有参构造方法赋值 + 结合getXXX()获取内容
		Phone p2 = new Phone("锤子手机",1299,"黑色") ; 
		System.out.println("品牌:"+p2.getBrand()+",价格:"+p2.getPrice()+",颜色:"+p2.getColor()) ;
	}
}

类的成员方法

成员方法其实就是我们前面讲过的方法

方法具体划分：

根据返回值分为：
有明确返回值方法和返回void类型的方法
根据形式参数分为：
		无参方法和带参方法

一个基本类的标准写法

类
成员变量
构造方法

	无参构造方法
	带参构造方法

成员方法

	 getXxx()
	 setXxx()

给成员变量赋值的方式

	无参构造方法+setXxx()
	带参构造方法

这篇关于java2106 第二周总结的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！