时光飞逝,已经第二周了,经过两个星期的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
这周的总结就到这里了,我需要学习的东西还有很多,自己总结的东西也是结合自己的理解以及老师的案例总结的,肯定有诸多不足之处,有不对的地方还请指正,谢谢…