Java之路第二弹

Java之路第二弹

时光飞逝,已经第二周了,经过两个星期的Java学习,越发明白, 在掌握哪些知识点时一定要吃透他们,要结合相关案例代码逐行逐句地从数据流向,从内存方面去分析方法,变量.这样才能打好坚实的基础.下面我整理一些这周学习过程中我认为重要的知识点

数组的应用

首先说一下数组的定义格式
//x表示数组x的长度,也就是它可以存放的整型个数
int[] arr = new int[x];
int arr[] = new int[x];
//但凡是new的都是在堆内存中申请一个空间为new int[x],并有一个空间地址 举例格式为:[I@6d06d69c 再将该空间地址赋值给arr对象.所以你若是输出arr 那就是输出了一个空间地址
前两种必须掌握 但是个人还是喜欢用方便的第三种
int[] arr = {x,y,z};
既开辟了空间,也赋值了地址,同时也将数组内容定义了,方便快捷.
当我们需要给定义好的数组赋值时,使用for循环
for(int i ; i < arr.length ; i++){
arr[i] = x;
}

接下来就是我认为有点难度的冒泡排序
冒泡排序的思想就时两两相邻的进行比较,较大的值向后排,所以排上一轮就会有一个最大值确定,而每确定一个最大值就能少一次比较,所以比普通的排序方法更加节省空间和排序的时间.下面列举一些代码:
/*

冒泡排序的思想:

	两两比较,将较大的值往后放,第一次比较完毕,最大值出现在最大索引处,依
	次这样比较...

	规律:
			两两比较,将较大的值往后放
			总共比较的次数:数组长度-1次

*/
class ArrayDemo{
public static void main(String[] args){

	//定义一个数组,静态初始化
	int[] arr = {24,60,87,57,13} ;
	
	//调用数组遍历的功能
	System.out.println("排序之前:") ;
	printArray(arr) ;
	
	/*
	//开始排序
	//第一次比较:
	//arr.length-1:防止角标越界
	//arr.length-1-0:为了减少比较的次数
	for(int x = 0 ; x < arr.length-1-0 ; x ++){
		//判断:两两比较,将较大的值往后放
		if(arr[x] > arr[x+1]){
			//交换
			//定义一个中间变量
			int temp = arr[x] ;
			arr[x] = arr[x+1] ;
			arr[x+1] = temp;
		}
	}
	
	System.out.println("第一次比较完毕:") ;
	//再次遍历
	printArray(arr) ;
	
	
	//第二次比较:
	//arr.length-1:防止角标越界
	//arr.length-1-1:为了减少比较的次数 :第二次比较:有一个元素不比(最大值已经出现了)
	for(int x = 0 ; x < arr.length -1-1; x++){
		if(arr[x] > arr[x+1]){
			int temp = arr[x] ;
			arr[x] = arr[x+1] ;
			arr[x+1] = temp ;
		}
	}
	
	System.out.println("第二次比较完毕:") ;
	//再次遍历
	printArray(arr) ;
	
	
	//第三次比较:
	//arr.length-1:防止角标越界
	//arr.length-1-2:为了减少比较的次数 :第三次比较:有2个元素不比
	for(int x = 0 ; x < arr.length -1-2; x++){
		if(arr[x] > arr[x+1]){
			int temp = arr[x] ;
			arr[x] = arr[x+1] ;
			arr[x+1] = temp ;
		}
	}
	
	System.out.println("第三次比较完毕:") ;
	//再次遍历
	printArray(arr) ;
	
	//第四次比较:
	//arr.length-1:防止角标越界
	//arr.length-1-3:为了减少比较的次数 :第四次比较:有3个元素不比
	for(int x = 0 ; x < arr.length -1-3; x++){
		if(arr[x] > arr[x+1]){
			int temp = arr[x] ;
			arr[x] = arr[x+1] ;
			arr[x+1] = temp ;
		}
	}
	
	System.out.println("第四次比较完毕:") ;
	//再次遍历
	printArray(arr) ;
	*/
	
	//优化:上面的代码重复度高, 使用循环改进
	//总共循环了四次
	for(int x = 0 ; x < 4 ; x ++ ){//循环次数
		for(int y = 0 ;y < arr.length-1-x; y++){ //元素比较
			//判断:
			if(arr[y] > arr[y+1]){
				int temp = arr[y] ;
				arr[y] = arr[y+1] ;
				arr[y+1] = temp ;
			}
		}
	}
	
	System.out.println("排序之后:") ;
	printArray(arr) ;
	
	System.out.println("-------------------------------") ;
	
	//问题:上面的4次,数出来的,它应该 比较的次数:数组长度-1次
	for(int x = 0 ; x < arr.length-1 ; x ++ ){//循环次数
		for(int y = 0 ;y < arr.length-1-x; y++){ //元素比较
			//判断:
			if(arr[y] > arr[y+1]){
				int temp = arr[y] ;
				arr[y] = arr[y+1] ;
				arr[y+1] = temp ;
			}
		}
	}
	System.out.println("排序之后:") ;
	printArray(arr) ;
	
	System.out.println("-------------------------------") ;
	//将排序的代码---->使用功能定义
	//调用冒泡排序的方法
	bubbleSort(arr) ;
	//遍历
	printArray(arr) ;
	
	
}
/*
	两个明确:
		1)明确返回值类型:void
		
		2)明确参数类型以及参数个数
			int类型数组
*/
public static void bubbleSort(int[] arr){
	for(int x = 0 ; x < arr.length-1 ; x ++ ){//循环次数
		for(int y = 0 ;y < arr.length-1-x; y++){ //元素比较
			//判断:
			if(arr[y] > arr[y+1]){
				int temp = arr[y] ;
				arr[y] = arr[y+1] ;
				arr[y+1] = temp ;
			}
		}
	}
}

//遍历的功能
public static void printArray(int[] arr){
	System.out.print("[");
	for(int x = 0 ; x < arr.length ; x ++){
		//判断
		if(x== arr.length-1){
			System.out.println(arr[x]+"]") ;
		}else{
			System.out.print(arr[x]+", ") ;
		}
	}
}

封装

接下来就是第三个知识点了
我们进入了封装环节,封装可以隐藏对象的属性和实现细节,仅对外提供公共方式,也就是无法直接调用封装的变量和方法.在我们使用封装时,可以有两个原则:将不需要对外提供的内容用private修饰,这样的话当别人想要调用的那些被private修饰的方法及变量的时候不可以直接调用访问,只能同过你自己创建的public方法进行方法,所以提高了安全性.所以在以后要养成封装的好习惯,养成良好的安全习惯.
在使用private修饰变量时,通常可以使用相应的get/set方法.下面举一个private修饰的和get/set方法:
//定义一个学生类
class Student{
//成员变量私有化
private String name ; //姓名
private int age; //年龄

//提供公共的访问方法赋值 setXXX/getXXX方法 XXX对应的属性名称
//给姓名赋值
public void setName(String n){ //传递一个具体的"字符串"
	 name = n ; //举例 :n = "高圆圆"
}
//给年龄赋值
public void setAge(int a){ //传递一个具体的 年龄值
	age = a ; //a = 20 ;
}

//获取姓名
public String getName(){
	return name ;
}
//获取年龄
public int getAge(){
	return age ;
}

//其他的成员方法:
public void study(){
	System.out.println("学习Java中的面向对象...") ;
}

}

//测试类
class StudentTest{

public static void main(String[] args){
	//测试:
	//创建一个学生类
	Student s = new Student() ;
	//name,age已经私有化了,只能通过公共方法赋值和获取值
	/*
	s.name = "高圆圆" ;
	s.age = 39 ;
	System.out.println(s.name+"---"+s.age) ;
	*/
	System.out.println(s.getName()+"---"+s.getAge()) ;
	//赋值
	s.setName("高圆圆") ;
	s.setAge(39) ;
	System.out.println(s.getName()+"---"+s.getAge()) ;
	s.study() ;
}

}

这个例子上半部分就是我所说的将变量封装并实现相应的get/set方法
下面测试类就可模拟他人调用你的类是使用set方法赋值,使用get方法获取值的模拟.简单说一下下面的测试类,首先创建一个Student,对象s即创建new Student()的堆地址,也可理解为s的就是类Student的地址,所以s就能通过地址指向类Student里面的方法,就是因为私有化的方法在别的类里面不可以直接访问,所以创建set/get的public也就是公共方法进行访问,然后调用set方法,将值赋值给上面被私有化的变量,再通过下面的get方法获取变量,通过return 返回回来那个你需要的被私有化的变量.此时就实现了对私有方法的赋值和调用.

接下来是这周觉得有些问题的static修饰符,也叫静态变量修饰符,静态修饰符static修饰符定义在方法区开辟的一片静态方法区,它是随着类的加载而加载的,也就是说他和类是同时创建的,这也就有利于我们理解为什么普通方法内不能定义static静态变量,因为方法还没创建,变量已经随着类的创建而创建出来了,所以在逻辑上说不通.

同时,static有个很重要的属性,它可以实现数据的共用
此处引用文章静态的成员变量存放在方法区里面的静态区。在加载class文件时.class文件区对于静态成员变量存放的是她在静态区的地址，非静态成员变量存放在class文件区即有了默认的初始值，在new一个对象时，把class内容（成员变量和方法）复制一份放在堆区，静态变量复制过去的也是他的地址。在给对象赋值时，即在堆区的对象的变量赋值，该值存在于堆区。而对象在使用静态变量时，根据堆中存放的地址，找到静态区中的静态变量，对其进行赋值。当创建第二个对象对该静态变量进行使用时，同样是根据地址找到静态区中的静态变量，此时该变量已经有了第一个对象对其赋的值，所以第二个对象在使用时得到的还是第一个对象赋值，这样就不用多次赋值了。如果第二个对象对该变量重新赋值了，那么静态区中该变量的值发生改变，再次访问此变量时就是改变后的值。即便是使用该变量的对象是在重新赋值之前已经创建好的，在她访问该变量时还是按照访问时的值进行使用。

即针对static修饰的成员，class文件中和堆内存中保存的都是静态标记（地址），该静态成员变量真正的值在静态区。静态区中存储的有静态变量也有静态方法（比如main方法）。

静态方法的调用方式与非静态变量的调用方式不同，静态成员变量由于其值是被所有对象共享的，所以他不属于某一个对象，它属于整个类共有的，因而调用该静态变量时可以直接使用类名.变量名，而非静态变量调用时需要创建对象，通过对象名.变量名。
————————————————
版权声明：本文为CSDN博主「QYHuiiQ」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/QYHuiiQ/article/details/80040365

这周的总结就到这里了,我需要学习的东西还有很多,自己总结的东西也是结合自己的理解以及老师的案例总结的,肯定有诸多不足之处,有不对的地方还请指正,谢谢…