Java第二周学习基础知识

跳转控制语句break，continue，return

break：表示结束中断，；单独使用没有意义，一般只能在switch或者循环语句中使用
contiue：结束当前循环，立即进入下一个循环，单独使用没有意义，contiue在loop外部循环使用
return：一般很少单独去使用，一般结束方法用的

方法

1.概念：就是使用{}包起来的内容，给{}包起来的 代码块起一个名字一边服用，定义一个方法
2.定义方法的格式：
第一种情况：有返回值类型的方法
权限修饰符 静态修饰符 返回值列表 方法名（形参列表）{
方法体；
return 结果；
}
第二种情况：没有具体返回值类型：
权限修饰符 静态修饰符 返回值列表（void） 方法名（形参列表）{
方法体；
}
解释格式：
权限修饰符：public 公共的公开的，访问权限最大
静态修饰符：static
返回值类型：数据类型（目前基本数据类型）
方法名：给{}里的代码块起一个名字，方法名要遵守见名起义
形式参数： 数据类型 ：目前基本数据类型
变量名：要符合标识符的规则
return：表示结束方法，调用方法的时候给具体返回结果，如果没有return报错
3.定义方法的两个明确
1）明确返回值类型
2）明确参数类型以及蚕食个数
4.调用方法
1）有返回值类型的调用
a.单独调用：没有意义
b.输出调用：直接去使用了，不利于后期对该结果的操作
c.赋值调用
2）没有返回值类型调用
没有返回值类型的方法，只能用单独调用
5.方法重载
方法名相同，参数列表不同与返回值无关
参数列表不同：
1）要么类型不同
2）要么参数个数不同

数组

1.概念：是一种容器，可以存储同一种类型元素的一种容器
2.数组的定义：数据类型[] 数组名称
数据类型 数组名称[]
3.数组的两种初始化
动态初始化：开发者定义数组初始化的时候，指定数组的长度，系统默认给数组中的元素赋值
静态初始化：直接指定数组的原不俗内容，系统指定的数组长度
4.动态初始化
数据类型[] 数组名称=new 数据类型[数组长度]
数据类型 数组名称[]=new 数据类型[数组长度]
5.静态初始化
1）概念：指定的元素的内容，系统默认长度
2）格式：数据类型[] 数组名称=new 数据类型[] {元素1，元素2，元素3…}
数据类型[]={元素1，元素2，元素3…}；
6.元素逆序

class ArrayTest3{
	public static void main(String[] args){
	
		//定义一个数组,静态初始化
		int[] arr = {57,87,96,13,24} ;
		
		//在逆序之前,先去遍历这个数组(将元素一一打印)
		System.out.println("逆序之前:") ;
		printArray(arr) ;
		
		//逆序
		//调用逆序的功能
		//reverse(arr) ;
		reverse2(arr) ;
		
		
		//遍历一下
		System.out.println("逆序后:");
		printArray(arr) ;	
	}
	/
	public static void reverse2(int[] arr){
		//在一个for循环中定义一个两个变量
		//start:表示开始索引
		//end:最终最大索引
		for(int start = 0,end = arr.length -1 ; start<=end ;start ++,end -- ){
			//中间第三方变量
			int temp = arr[start] ;
			arr[start] = arr[end] ;
			arr[end] = temp ;
		}
	}

7.数组查表法
通过数组名称[角标值]确定内容
数组的基本查找发：从数组中的开始索引一直查询到末尾，查询出元素第一次在数组中的数值

class ArrayTest5{
	public static void main(String[] args){
		
		//定义数组,静态初始化
		int[] arr = {87,200,300,450,96,24} ;
		
		//查询4500这个元素在数组中的索引值:
		int index = getIndex(arr,4500) ;
		System.out.println(index) ;
		System.out.println("----------------");
		int index2 = getIndex(arr,96) ;
		System.out.println("index2:"+index2) ;
		System.out.println("----------------");
		int index3 = getIndex(arr,240) ;
		System.out.println("index3:"+index3) ;
	}
	
	//方式2:假设法:
	public static int getIndex2(int[] arr,int key){
		//假设元素找不到
		//定义一个变量
		int index = -1 ;
		
		//遍历数组arr
		for(int x = 0 ; x < arr.length ; x ++){
			//获取到每一个元素
			if(arr[x] == key){
				//将index的值更改掉
				index = x ; 
				break ;
			}
		}
		return index ;
	}
	
	/*
		定义查询角标的方法
		两个明确
			1)明确返回值类型:int
			2)明确参数类型以及参数个数
				int的数组以及int类型的元素,2个参数
	*/
	//参数1:在已知的数组中查询元素
	//参数2:在arr数组中查询key这个元素
	public static int getIndex(int[] arr,int key){
		//1)遍历arr数组
		for(int x = 0 ; x < arr.length ; x ++){
			//获取到每一个元素
			//判断:如果arr[x] == key ---- >查找到这个元素,返回角标值
			if(arr[x] == key){
				return x ;
			}
		}
		
		//对于判断:要么成立,要么不成立 (成立,表示查询到了)
		//如果元素没有在数组中出现,查不到,要考虑返回某个值 "负数" 一般找不到:-1
		return -1 ;
	}
	
	
}

8.冒泡排序（重点）
思想：两两比较，较大的值往后放，第一次比较完毕，最大值就出现最大索引位，依次这样比较，就可以得到一个排好序的数组

class ArrayTest{
	public static void main(String[] args){
		//定义一个数组,静态初始化
		int[] arr = {57,69,80,13,22} ;
		//需求:遍历arr数组,最终以 [元素1, 元素2, 元素3, ....元素n]格式出现  变成功能
		//调用
		printArray2(arr) ;
		printArray2(arr2) ;
		
	}
	//最终版代码:遍历数组
	public static void printArray2(int[] array){
		//拼接左中括号
		System.out.print("[") ;
		//遍历array数组
		for(int x = 0 ; x < array.length; x ++){//x角标
			//获取到每一个元素
			//判断:如果x取到最大索引值,---->取到最后一个元素了
			if(x==array.length-1){
				//最后一个元素,输出元素内容以及右中括号
				System.out.println(array[x]+"]") ;
			}else{
				//不是取到最大索引值,将中间的元素按照按照格式输出(元素+逗号+空格)
				System.out.print(array[x]+", ") ;
			}
		
		}
	}
	
	/*
		遍历的功能
		定义一个方法
		
			两个明确
				1)明确返回值类型:void 
				2)明确参数类型以及参数格式
					int类型的数组  1个参数
	*/ 
	public static void printArray(int[] array){//方法的形式参数:传递的是一个引用类型:数组
		for(int x = 0 ; x < array.length ; x ++){
			System.out.println(array[x]) ;
		}
	}
	
}

二维数组

1.概念：其实就是一个元素为一维数组的数组
2.定义格式：
数据类型[] 数组名称[]；
数据类型[][] 数组名称
3.动态初始化
格式一：
数据类型[][]数组名称 =new 数据类型[m][n]
格式二：
数据类型[][]数组名称 =new 数据类型[m][]
格式三：（静态初始化）
数据类型[][] 数组名称=new 数据类型[][]{{元素1，元素2，元素3}，{元素1，元素2，元素3}。。。。}
4.二维数组的遍历

class Array2Test{
	public static void main(String[] args){
		
		//定义一个二维数组,静态初始化:
		int[][] arr = {{1,2,3},{4,5},{6}};  
	
		//调用遍历的功能
		printArray2(arr) ;
	}
	/*
		两个明确
			1)明确返回值类型:void
			2)明确参数类型以及参数个数
				1个参数 int类型二维数组
					
	*/
	public static void printArray2(int[][] arr){
		//输出以下左大括号
		System.out.print("{");
		//遍历
		for(int x = 0 ; x < arr.length; x++){//外层循环是一维数组的个数
			//先输出左大括号
			System.out.print("{");
			//遍历一维数组的元素
			for(int y = 0 ; y < arr[x].length ; y++){
				//判断
				//如果是二维数组的最后一个元素
				if(x == arr.length-1){
					//输出元素值以及后面的}
					System.out.print(arr[x][y]+"}") ;
					
					//如果当前元素取到的一维数组的最后一个元素
				}else if(y == arr[x].length-1){
					//输出元素内容以及}以及,
					System.out.print(arr[x][y]+"}"+",") ;
				}else{
					System.out.print(arr[x][y]+",") ;
				}
			}
			
		}
		//输出整个右}
		System.out.print("}");
	}
}

面向对象

面向对象的思想特点：
1）更符合生活中的思想行为习惯
2）让复杂的事情简单化
3）让我们从执行者变成一个指挥者
面向对象的设计原则：
创建对象，是想对象，指挥该对象做东西
面向对象的三大特征
封装，继承，多态

类和事物

事物：描述现实世界的真实存在的泛指的东西
类：是描述一组事物的属性和行为的集合
学生事物---------->代码体现出来：类：学生类 classStudent
属性：描述学生的特征（姓名，年龄，学号，性别）成员变量 位置：在类中方法外
行为：描述学生能干什么 成员方法（去掉static）
public 返回值类型 方法名（）{}
代码体现具体事务：创建该类对象
类名 对象名=new 类名（）；
对象名.成员变量
对象名.name=“张三”;
对象名.成员方法

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

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

封装

概念：将类中成员变量私有化，对外提供公共的访问方法
private的特点：
1）private可以修饰一个类中的成员变量，也可以是成员方法
2）被private修饰的成员变量或者成员方法只能在本类中访问，外界是不能访问的

构造方法

概念：方法名和类名相同，没有具体的返回值类型，并且连void都没有
格式：public 类名（）{}
作用：就是给该对象中的数据进行初始化

static修饰符

静态的特点：
1）被static修饰的变量/方法都随着类的加载而加载
2）被static修饰优先于对象存在
3）被static修饰的可以被多个对象使用
4）被静态修饰的成员变量或者成员方法可以被类名直接访问，但是也可以用该类对象访问该成员
关于成员方法的访问问题：
非静态的成员方法：
既可以访问静态的成员变量，也可以访问非静态的成员变量
既可以访问静态的成员方法，也可以访问非静态的成员方法
静态的成员方法
静态只能访问静态

面试题

Student s=new Student（）做了那些事情？（从内存角度来说）
1）加载studengt.class进内存
2）在栈内存中开辟栈内存空间
3）在堆内存中申请空间
4）对数据进行初始化
a.系统默认初始化
b.显式初始化------setxxx（形参）构造方法赋值
5）堆内存中申请空间完毕，产生一个堆内存地址
6）将堆内存地址赋值给栈内存变量s
7）栈内存变量s堆内存地址

什么时候将变量定义为成员变量

如果这个变量能够描述当前类（事物）的属性的话，这个时候将变量定义为成员变量；否则就是局部变量
实际开发中，变量的范围越小越好（局部变量）