java2106 第二周总结

本文主要是介绍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 第二周总结的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

java2106 第二周总结

本周总结

一、switch语句的应用

二、循环语句

1、循环语句----for

格式

执行流程

举例

2、 循环语句----while

格式

执行流程

举例

for和while的区别

3、 死循环

示例

4、循环语句—do_while

格式

do…while循环的特点

举例

5、for循环嵌套

概念：

格式

举例

三、跳转控制语句

1、break

使用示范

2、continue

使用示范

3、return

使用示范

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

四、方法

概念

Java中定义方法的格式:

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

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

注意事项

举例

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

举例

—方法重载

方法重载(overload) :

方法重载的目的:

方法重载的特点

方法的形式参数问题:

五、数组

数组概念：

数组的定义格式:

1)动态初始化

格式：

2)静态初始化

格式：

程序报错（了解）:

静态初始化应用

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

Java中的内存分配

六、面向对象

1、引入

面向对象基于面向过程:

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

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

封装,继承,多态

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

4、类与对象的关系

5、类的定义

例题

6、成员变量和局部变量

成员变量：

局部变量：

区别

形式参数问题

7、 匿名对象

概念

格式

8、封装

封装概述

好处：

封装原则：

封装目的:

private关键字:

2、循环语句----while

3、死循环

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

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

7、匿名对象