【java基础学习week2

第二周周总结

流程控制语以后

switch语句

** 注意事项**
格式:
switch(值){

case 值1:
break;
case 值2:
break;
…
default :
break;

}

面试题考点

1.case语句后面只能跟常量
2.关于Switch后面数据类型
   基本数据类型 byte,short ,int,char
   jdk5以后可以是枚举
   jdk7 以后可以是String
3.看见break跳出循环 否则依次执行到语句末尾
4,没有匹配值时候 执行default语句,
default 可以是任何位置,在句末break可以省略,但是在句中不能省略,否则会case穿透(考点),也可以在实际中利用case穿透

循环控制语句

  do {


执行语句;
}while(判断条件);

特点:无论条件是否成立,都是先执行一次, 再判断;

for(初始化变量;判断条件;控制体语句){

   循环体;
}


while (判断条件){
循环体语句;
控制体语句;
}
  
  

** for和while的差异:**

共同点:都是循环思想,解决代码冗余问题
不同点:
1)使用场景不同:
for 在明确循环次数时使用
while 不明确循环次数时使用

2)格式不同

3)从内存资源消耗来看:
for 循环比较节省空间,for循环结束,变量就被释放;
while 循环相对for循环来说,比较耗内存,循环结束时,变量还可以访问的到;

死循环

  for(; ;){

循环体;
}

while(true){

循环体;
控制体语句:

}

流程控制语句

(考点)

break:使用范围大,结束,中断,在Switch中用或者循环中使用;
continue:结束当前循环,进入下次循环(不进入判断语句)
return:方法中,结束方法区使用,一般,携带返回的结果;很少单独使用

java中的方法

    方法:就是将某段逻辑代码用{}包起来,方便重复使用
    
    定义格式:
    1)有返回值类型的
      权限修饰符  状态修饰符  返回值类型 方法名(参数类型 参数名){
      方法体;
      return 0;
      }
    2)没有返回值类型的定义
       权限修饰符  状态修饰符  void 方法名(参数类型 参数名){
      方法体;
      
      }
      
      方法调用:
      
      ![f1f860358ee8147e4d335c343ef586cb.png](en-resource://database/650:0)
      
      

方法重载

`概念:
方法名相同,参数列表不同,与返回值无关:

参数列表不同;

1)参数个数不同
2)参数类型不同
3)参数顺序位置不同;

作用:
1)
  方法重载的主要好处就是不用为了对不同的参数类型或参数个数，而写多个函数
2)
重载的最直接作用是方便了程序员可以根据不同的参数个数，顺序，类型，自动匹配方法，减少写这个函数名或方法名的重复步骤。

数组

概念:

数组是一种容器,只能存储同一类型的元素

定义格式:

动态数组:
     数据类型 [] 数组名 = new 数据类型[初始化长度];
 静态数组:
     数据类型[]  数组名 = {......};

注意事项:
初始化的时候不能动静结合,只能有一种;

遍历数组的步骤:

public static void main(){

int[] arr = new int[8];
arrayBianli(arr);
}
public static void arrayBianli(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]+", ")
       }
     }  
   }

面试题

int[] arr = new int[3];这句话,完成了哪些事情???

(从内存的角度出发思考)
1)数组类型变量int[] arr 先要在栈内存中开辟空间;
2)new int[3];需要在堆内存中申请空间
3)为这个堆内存中的这些 数组元素,进行系统默认初始化
4)初始化完毕,为堆内存空间产生一个空间地址值
5)将产生的空间地址值赋值给变量arr
6)arr变量的地址指向堆内申请的空间

冒泡排序

思想:

两两比较,大的往后;第一次比较完,最大值出现在最最后位置;依次循环比较思想

代码实现:

      //遍历输出代码:  
      public static void printArray(int[] arr){
      System.out.print("[");
      for(int x=0;x<arr.length;x++)
      if(x==arr.length-1){  //如果x值取到最大索引
      system.out.println(arr[x]+"]")
      }else{
      System.out.print(arr[x]+",");
        }
      }
      
      //冒泡排序代码:
      public static void sort(int[] arr){
        for(int x=o;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];
      arry[] = arr[arr.length-1-x];
      arr[arr.length-1-x]=temp;
            }
         }
        }
      }

逆序排序:

思想

通过控制循环遍历所有数组条件是  小于数组最大长度的二分之一  ,核心思想,  定义中间变量  变量temp 将第一个arr[0]值赋值给temp,将最后值arr[arr.length-1-x]  赋值给arr[0] ,再将temp赋值给arr[0];
三元转换思想 


代码实现:

     public static void arrayNixu_1(int[] arr){
     //  方法一:      
     /* 
     for (int a=0,b=arr.length-1;a<b;a++ ,b--){           
     int temp = arr[a];               
     arr[a] = arr[b];               
     arr[b] = temp;       
     }
     
     */ 

方法二:      
for (int a= 0;a<arr.length/2;a++){    
       int temp = arr[a];          
       arr[a] = arr[arr.length-1-a];        
       arr[arr.length-1-a] = temp;    
          }   
       }

java.long.Math类获取随机数的特点以及如何获取到1-100之间的随机数

**特点: **

 获取随机数的方法: Math.random();   取值范围 [0.0 -1.0)  取不到1.0;

 如何获取1-100之间的随机数:
 int num = (int)(Math.random();)*100+1;

java中的循环求和思想:

思想:

使用步骤:

• 1)定义一个最终结果变量sum,从0开始记录
• 2)使用for(初始化语句;条件表达式;控制体语句){ * //循环体语句 * //先取出来每一个数据 * 使用结果变量就是上面的数据求和,然后 再赋值给最终结果变量; * }
• 3)输出sum即可

代码实现:

  public static void main(String[] args){
    //求1-10之间的数据和
    for(int x=1;x<=10;x++){
    int sum = 0;
    sum += x;
    }
    System.out.prrintln(sum);
  }

java中的水仙花数

 **概念:**

 水仙花指的是三位数,而且这个三位数的每一个位上的立方相加就是 当期数据本身;

** 获取100-999之间的水仙花数 代码实现:**

    public static void main(String[] args){
    
       for(int x=100,x<1000;x++){
          int ge = x %10;  //获取最低位
          int shi = x/10%10;  //获取十位
          int bai = x/10/10%10; //获取百位置
          if(x==ge*ge*ge +shi*shi*shi*+bai+bai+bai){
          System.out.println(x)
          
             }
         
         }
  
    }

java中jvm内存分配:

栈内存:    存储局部变量用的这个内存区域 
堆内存:    new 出来的对象 存储这个区域 
方法区:    字节码文件区域----方法调用过程需要加载类 里面存储很多的                  方 法,这些方法被调用,加载进 栈内存

         static区域 ----- main方法就是被static修饰的  
        常量池 ----- 常量的都是在常量池 后面和cpu以及系统相关
        
寄存器: 
本地方法区:
        java语言开源,但是很多底层一些东西(线程--依赖于进程),底层c语言操作的 jdk源码上:方法上 关键字native:非java语言实现

面向对象的思想特点:

** 思想特点:**

   1)更符合生活中的思想行为习惯
  2)让复杂的事情简单化
 3)从执行者变成了指挥者

 三大特征:
 
 封装,继承,多态

什么是类:

类-----是描述现实世界事物的属性和行为的集合;

代码体现:
class 类名{
属性1;
属性2;
//行为
方法();
方法2();
}

代码示例:

   
   public class Student {    
   String name;   
   int age ;   
   String sex;    
   public void study(){        
   System.out.println("老王爱学习!");    
   }    
   public void playGame(String styleGame){        System.out.println("老王爱打"+styleGame);    
  
         }
   }

封装:

概念:

  就是将现实世界事物的属性隐藏了(加入一个关键字 private),  私有的无法直接访问的,保证对外数据的安全性!(外界不能访问的) 
  对外提供一个方法,公共的(public)访问方法(setXXX()/getXXX();)
  
  注意事项;
    以后在书写代码的时候,写一个类,描述真实事物的属性的时候,需要全部加入private 
    
    面试题:
    private关键字的特点:
    1)被private修饰的成员变量以及成员方法只能在本类中访问
    2)可以修饰成员变量,也可以是成员方法,就是为了外界不能直接访问
    3)被private修饰的成员变量或者方法可以间接的通过公共的方法访问的到: