第二周总结

第二周总结

do-while循环语句

格式:

初始化语句：
do{
循环语句;
步长语句;
}while(条件表达式);

do-while与while的最大区别： do-while中的循环体至少执行一次

for循环的嵌套

跳转控制语句

break：表示中断，结束

应用场景：单独使用，没有意义；在switch语句或者循环语句中使用

continue：（继续）结束当前循环，立即开始下一次循环

应用场景：单独使用，没有意义，continue在loop外部（循环外部）

return：一般很少单独使用，一般结束方法使用

应用场景：return是结合方法去使用的，如果一个方法中有return，具体返回结果

标签语句

代码示例：

//3行4列的*
	wc:for(int x=0; x<3 ;x ++){//行数
		nc:for(int y =0;y <4 ; y++){//列数
			if(y ==2){
			//break 标签名称;
			//break wc;//结束外层循环（当前输出第一行的时候,到第二列的时候结束for循环)
			break nc;
			}
		System.out.print("*");
		}
		System.out.println() ;
	}

输出结果

**
**
**

Java中的方法

一个方法只能返回一种类型的数据，如果传入两种数据运算需要强制转换。

方法的概念： 用{}将代码块包起来，并赋予一个名称（见文知意），方便复用
定义方法的格式：public static 返回值类型 方法名（变量名1 变量1，变量名2 变量2……）{}
定义方法之两个明确：1.明确返回值类型
				   2.明确形参的类型以及个数
权限修饰符：public 公共的，公开的，访问权限最大的 
静态修饰符：static 
返回值类型：任意数据类型
方法名：给{}代码块起一个名字，符合见文知意（遵循标识符命名规则）
形式参数：
		数据类型：任意数据类型
		变量名：符合标识符命名规则
return：表示结束方法，调用方法的时候给一个具体的返回值；如果没有return，报错
调用方法：
		单独调用：无意义，没有输出结果
		输出调用：没有问题，但是直接输出，不利于后期对该结果的操作
		赋值调用：（推荐方式）便于后期操作以及运算
注意事项：1.方法和方法是平级关系，不能在一个方法中定义另一个方法（不能在main方法中定义方法）
		 2.在定义方法的时候（目前来说）必须要带上static
		 3.在定义一个有返回值类型的方法的时候
			a.明确返回值类型
			b.明确参数类型和参数个数
		 4.定义方法时候必须带上形参的数据类型
	方法的形式参数如果是基本的数据类型，形式参数的改变不会影响实际参数（传递的是具体的值）
	方法的形式参数如果传递的是引用类型（数组，类，接口），形式参数的改变会直接影响实际参数（传递的值是空间地址）
	String是最特殊引用类型，它如果作为形式参数特点跟基本数据类型一样（不会影响实际参数）`

没有具体返回值的方法

1.定义格式：public static  void 方法名（参数类型1 变量名1，参数类型2  变量名2，……）{
			方法体;
			}
2.调用方法：只能单独调用（因为没有返回值）

有返回值类型的方法

格式：public static 返回值类型 方法名（变量名1 变量1，变量名2 变量2……）{ 
			方法体;
			return 返回值;
			}
有具体返回值类型的方法定义：
	1.定义初始化变量
	2.调用方法
	3.将实参传给形参（将变量传入方法中）
	4.方法计算结果并将值返回给调用者
	5.带回结果
	6.输出结果

方法重载

特点：方法名相同，参数列表不同（数量或者类型），与返回值无关

数组

概念：数组是一种“容器”，可以存储同一种元素的“容器”
注意：必须要保证该容器中的存储类型必须一致
定义：数据类型[]   数组名称；
      数据类型   数组名称[];
初始化 ：
静态初始化：直接指定数组的元素内容，系统指定数组的长度
	  格式：数据类型[] 数组名称=new 数据类型[] {元素1，元素2，元素3……}；
      简写方式：数据类型[] 数组名称={元素1，元素2，元素3……}；
动态初始化：指定数组长度，系统会自动给数组中的元素赋默认值
	  格式：数据类型[]  数组名称=new 数据类型[数组长度]；

数组的应用

遍历：将元素的内容按顺序一一输出出来

遍历的功能（方法）：定义一个方法将元素的内容一一输出出来
两个明确：1.明确返回值类型：void
  		 2.明确参数类型以及参数格式（传入一个数组）

System.out.print("[");
	for(int i=0;i<arr.length;i++){//对数组进行遍历并输出
		System.out.print(arr[i]);
	}
System.out.print("]");

数组的最值问题：求最大值/最小值

分析：
	1.定义数组，静态初始化
    2.定义一个参照物（数组的第一个元素）
    3.从第二个元素开始遍历，获取到每一个元素，然后依次与参照物比较，将较大/较小的元素赋给参照物
    4.输出最大/最小值

	public static int compare(int[] x){
		int temp=x[0];
	for(int i=0;i<x.length;i++){//依次遍历将最大值赋给temp
		if (x[i]>temp){
			temp=x[i];
		}
	}
		return temp;//返回最大值
	}

数组的逆序：倒着打印一遍

思想：将第一个（下标为0的元素）与最后一个（下标为数组.length-1-0）的元素进行交换
	 要保证遍历的次数小于arr.length/2

for(int j=0;j<(a.length)/2;j++){
	int temp=0;
	temp=a[j];
	a[j]=a[a.length-1-j];
	a[a.length-1-j]=temp;
}

数组的基本元素查找法：查找元素中的某一个元素的第一次出现的角标值

方法：通过数组名称[角标值]确定内容

查询元素

查询元素角标

数组的高级排序：冒泡排序

思想：两两比较，将较大的值往后放，第一次比较完毕，最大值出现在最大索引处，依次这样比较
规律：两两比较，将较大的值往后放
总共比较次数：数组长度-1次

冒泡思想代码

for (int j=0;j<a.length-1;j++){//总共循环a.length-1次
for(int k=0;k<a.length-1-j;k++){//第n次有n个不比较；第1次有1个不比较;
	if(a[k]>a[k+1]){//两两比较,将较大的值往后放
		int temp=a[k];//创建一个中间变量,并将大的值赋给中间变量
		a[k]=a[k+1];//将小的值赋给前者
		a[k+1]=temp;//将大的值赋给后者
	}
}
}

二维数组

其实就是一个元素为一维数组的数组
定义：数据类型[] 数组名称[] ;
	  数据类型[][] 数组名称 ；
格式1:数据类型[][] 数组名称 = new 数据类型[m][n] ;
格式2:指定了一维数组的个数,一维数组的长度需要动态给定（动态初始化）
	  数据类型[][] 数组名称 = new 数据类型[m][] ;//一维数组必须定义，否则报错
格式3:静态初始化
	数据类型[][] 数组名称 =new 数据类型[][]{{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};
	简写：数据类型[][] 数组名称 ={{元素1,元素2,元素3..},{元素1,元素2,元素3,...},{,}};

二维数组遍历

二维数组求和

杨辉三角

面向对象

思想特点

特点：基于面向过程的一种思想
面向过程：c语言
面向对象：Java语言
总结思想特点：1.更符合生活中的思想行为习惯
  		  2.让复杂的事情简单化
   		  3.从执行者变成指挥者
面向对象设计原则：创建对象，使用对象，指挥该对象做事情

三大特征：封装，继承，多态
类和事物的关系

事物：现实生活中具体存在的
类：Java中最基本的单元
类和事物的关系：
		事物：描述现实世界的真实存在的具体的
		类：是java中描述一组事物的属性和行为的集合
		事物中的属性————>类中的成员变量
		事物的行为————>类中的成员方法

局部变量和成员变量的区别

1.在类中的位置不同
	局部变量：在方法中或者是方法声明上的变量
	成员变量：在类中方法外定义的变量
2.在内存中的位置不同
	局部变量：在栈中存储  跟方法有关
	成员变量：在堆中存储  跟类的对象有关
3.生命周期不同
	局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
	成员变量：随着对象的创建而存在，随着对象的创建完毕并且使用完毕，等待垃圾回收之后才消失
4.初始化时机不同
	局部变量：在方法定义中或者在方法声明上的变量，必须在使用之前对数据初始化，否则“可能尚未初始化变量”
	成员变量：跟对象有关系，在堆内存中，即使这个变量没有赋值，系统会根据变量的类型给这个变量进行默认初始化

匿名对象

匿名对象：没有名字的对象
	格式：new 类名（）；//前提条件：该类是一个具体类
		  new 类名（）.方法（new 类名（））；
特点：1.仅使用一次，使用完毕，从内存中立即释放（节省内存空间，android移动端使用居多）
      2.匿名对象可以作为参数进行传递
注意：使用匿名对象的时候，不建议使用多次！

封装————private：私有的，外界无法访问的

封装：将类中的成员变量私有化，对外提供一个公共的访问方法（入口）
私有化成员变量：只能在本类中访问，外界无法访问；
private关键字的特点：
	1.可以修饰一个类中的成员变量，也可以修饰成员方法
	2.被private修饰的成员变量或者成员方法只能在本类中访问，外界不能访问！（保证数据的安全性）

this关键字

含义：代表当前类的对象的地址值引用，防止局部变量和成员变量出现了冲突（局部变量隐藏了成员变量）
	例如：name=name
this.成员变量；//访问本类的成员变量
this.成员方法（）；//访问本类的成员方法
this（）访问无参构造方法//访问本类的无参构造方法
this（XXX）访问带参构造方法//访问本类有参构造方法
this这个关键字指代本类中的一个对象，但是具体指代本类中的哪个对象呢？
		– 谁调用我我指代谁。

标准类的写法

标准类：属性私有化，加入构造方法
		1.成员变量私有化
		2.提供无参/有参构造方法
		3.提供对外的公共的setXXX（形式参数）/getXXX（）方法
		4.功能性的方法

构造方法

构造方法的作用：创建对象，并且创建对象的过程中给属性赋值（初始化）
定义：1.方法名和类名相同
	  2.没有具体的返回值类型
      3.连void都没有
分类：无参构造方法：public 类名（）；
      有参构造方法：public 类名（数据类型1 变量名1，数据类型2 变量名2）；
注意事项：1.在一个类中，我们不写构造方法，系统会默认提供一个无参构造方法
 		   2.如果我们提供一个有参构造方法，系统就不会提供无参构造方法，所以建议一直把无参构造方法手动写出来

成员方法

成员方法的分类:(非静态的成员方法)
		两种情况:
			要么有返回值类型
				1)有返回值类型,并且有参数
				2)有返回值类型,没有参数
			要么没有具体返回值:void代替
				1)没有返回值类型,带参
				2)没有返回值类,不带参

static关键字

static 关键字可以用来修饰：属性、方法、内部类、代码块；
static 修饰的资源属于类级别，是全体对象实例共享的资源；
使用 static 修饰的属性，静态属性是在类的加载期间初始化的，使用类名.属性访问
访问方式：推荐使用类名.成员名；的方式访问
static特点：
	1.被static修饰的变量/方法，都随着类的加载而加载
	2.被static修饰的      优先于对象存在
	3.被static修饰的可以被多个对象共用（什么时候使用静态变量？多个对象共用的属性）
	4.被static修饰的成员变量或成员方法可以使用类名.方法名（）或者类名.变量名访问
注意事项：
	1.在static中，是没有this关键字的！（this代表当前对象的地址值，意味着对象已经创建，而static关键字和类有关）
	2.关于成员方法的访问问题：
		非静态的成员方法：既可以访问静态成员变量，也可以访问非静态的成员变量
		    			 既可以访问静态成员方法，也可以访问非静态成员方法
		非静态的成员方法：简单记：静态只能访问静态

创建对象过程面试题

Student s=new Student();做了哪些事情？（创建对象做了哪些事情）
	1.加载Student.class进内存
	2.在栈内存中开辟栈内存空间
	3.在堆内存中申请空间
	4.对数据进行初始化（成员变量）
		4.1系统默认初始化
		4.2显式初始化（setXX（形参）/构造方法赋值）
	5.堆内存中申请空间完毕，产生一个堆内存地址
	6.将堆内存地址赋值给变量s
	7.栈内存变量s指向对内存地址

文档注释的使用
javadoc命令，将工具类的文档注释解析—产生文档说明书