小虾虾的JAVA基础阶段总结————才学不久，请大佬们狠狠处刑

JAVA开发环境

编译运行过程：

    从 .java源文件经过编译生成 .class字节码文件，通过JVM加载.class文件并运行。

JDK、JRE、JVM的区别：
JDK：java开发工具包，是java的核心，包括：JRE+编译、运行等命令工具。
JRE：java运行环境，是运行java程序所必须的环境集合，包括：JVM+java系统类库。
JVM：java虚拟机，是java实现跨平台的最核心部分，能够运行java语言所开发的程序。

变量

命名法
小驼峰命名法：第1个单词首字母小写，其余单词首字母大写。
帕斯卡命名法/大驼峰命名法：所有单词首字母大写。

八种基本数据类型
byte：字节型，用于存储整数的，占用1个字节，范围-128到127。
short：短整型，用于存储整数的，占用2个字节，范围-32768到32767。
int：最常用的整型，用于存储整数的，占用4个字节，范围-2^31到231-1。
long：长整型，用于存储较大的整数的，占用8个字节，范围-2^63到263-1。
float：单精度浮点型，用于存储小数的，占用 4个字节，不能表示精确的值。
double：双精度浮点型，最常用的存储小数的类型，占用8个字节，不能表示精确的值。
boolean：布尔型，用于存储true或false，占用1个字节
char：字符型，采用Unicode字符编码格式，用于存储单个字符，占用2个字节。

字符间的转化
小转大为隐性转换，即自动转换。
大转小为强制转换 ，强转可能会溢出或丢失精度。
byte,short,char型数据参与运算时，系统会将其自动转换为int类型再运算。

运算符

算数运算符
+、-、*、/、%、++、–

关系运算符
<、>=、<=、==、!=、>

逻辑运算符
&&、||、!

赋值
=、+=、-=、*=、/=、%=

字符串连接符
+

条件运算符
boolean?数1:数2

分支结构

任何复杂的程序逻辑都可以通过顺序结构,分支结构,循环结构三种结构来实现
if结构
1路

    1)语法:
        if(boolean){
           语句块--------------基于条件执行的语句
        }
     2)执行过程:
         判断boolean的值:
            若为true，则执行语句块(整个结束)
            若为false，则直接结束

if…else结构
2路

     1)语法:
        if(boolean){
           语句块1
        }else{
           语句块2
        }
     2)执行过程:
         判断boolean的值:
           若为true，则执行语句块1(整个结束)
           若为false，则执行语句块2(整个结束)
     3)说明:
         语句块1和语句块2，必走其中之一-------------2选1

if…else if
多路

     1)语法:
       if(boolean-1){
         语句块1
       }else if(boolean-2){
         语句块2
       }else if(boolean-3){
         语句块3
       }else{
         语句块4
       }
     2)执行过程:
         判断boolean-1，若为true则执行语句块1(结束)，若为false则
         再判断boolean-2，若为true则执行语句块2(结束)，若为false则
         再判断boolean-3，若为true则执行语句块3(结束)，若为false则执行语句块4(结束)
     3)说明:
         语句块1/2/3/4，必走其中之一--------多选1

switch…case
优点:效率高,结构清晰

缺点:只能对整数判断相等

switch中数据类型:byte,short,int,long,char,String,枚举

default位置:可以写在case前面但要加break

一般格式
       switch(整数变量){
           case 整数:
               语句;
               break;
           case 整数:
               语句;
               break;
           ...
           default:
               语句;
        }
           判断变量==case后的数,相等则结束分支
           都和case后的数不相等执行default的语句

循环结构

while循环结构
先判断后执行,有可能一次都不执行

     1)语法:
       while(boolean){
         语句块/循环体------------反复执行的代码
       }
     2)执行过程:
         先判断boolean的值，若为true则执行语句块，
         再判断boolean的值，若为true则再执行语句块，
         再判断boolean的值，若为true则再执行语句块，
         如此反复，直到boolean的值为false时，while循环结束

do…while循环结构
先执行后判断,至少执行一次

     1)语法:
       do{
         语句块
       }while(boolean);
     2)执行过程:
         先执行语句块，再判断boolean的值，若为true则
         再执行语句块，再判断boolean的值，若为true则
         再执行语句块，再判断boolean的值，若为true则
         再执行语句块，如此反复，直到boolean的值为false时，do...while结束

for循环结构

     1)语法:
         //    1    2    3
         for(要素1;要素2;要素3){
           语句块/循环体--------------反复执行的代码  4
         }
     2)执行过程:
         1243243243243243...2为false时，循环结束

嵌套循环
循环中套循环，常常多行多列时使用，外层控制行，内层控制列

执行规则：外层循环走一次，内层循环走所有次

建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层

break默认只能跳出当前一层循环

小结
如何选择循环：看循环是否与次数相关
相关…选择for
无关…do…while或者while

任何复杂的程序逻辑都可以通过三种结构来实现：
顺序结构：从上往下逐行执行，每句必走
分支结构：有条件的执行某语句一次，并非每句必走
循环结构：有条件的执行某语句多次，并非每句必走

变量的作用域/范围：
从变量的声明开始，到包括它最近的大括号结束
作用域重叠时，变量名不能相同

break：跳出当前一层循环

continue:跳出循环体中剩余语句而进行下一次循环

数组

一种相同数据类型元素的集合，是一种引用数据类型

定义

     //声明整型数组a，包含5个元素，每个元素都是int类型，默认值为0
     int[] a = new int[5];
     //声明浮点型数组d，包含10个元素，每个元素都是double类型，默认值为0.0
     double[] d = new double[10];
     //声明布尔型数组b，包含26个元素，每个元素都是boolean类型，默认值为false
     boolean[] b = new boolean[26]; 

初始化：初始化数组中的元素

     int[] arr1 = new int[3]; //0,0,0
     int[] arr2 = {2,5,8}; //2,5,8
     int[] arr3 = new int[]{2,5,8}; //2,5,8
     int[] arr4;
     //arr4 = {2,5,8}; //编译错误，此方式只能声明同时初始化
     arr4 = new int[]{2,5,8}; //正确

访问
同过（数组名.length）可以获取数组的长度

       int[] arr = new int[3];
       System.out.println("数组的长度:"+arr.length); //3

通过下标/索引来访问元素，下标从0开始，到最大（数组的长度-1）

       int[] arr = new int[3];
       System.out.println("数组的长度:"+arr.length); //3
       System.out.println(arr[0]); //0，输出第1个元素的值
       arr[0] = 100; //给第1个元素赋值为100
       arr[1] = 200; //给第2个元素赋值为200
       arr[2] = 300; //给第3个元素赋值为300
       //arr[3] = 400; //运行时会发生数组下标越界异常
       System.out.println(arr[arr.length-1]); //300，输出最后一个元素的值

遍历/迭代

 int[] arr = new int[10];
     for(int i=0;i<arr.length;i++){ //遍历arr数组
         arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99的随机数
         System.out.println(arr[i]); //输出每个元素的值
     }

排序
将数组型小到大排列可以调用：Arrays.sort(arr);

数组默认值

   byte,short,int,long,char-------------0
   float,double-------------------------0.0
   boolean------------------------------false
   其他----------------------------------null

复制
方法1：
可以给数组插入元素

     int[] a = {10,20,30,40,50};
     int[] b = new int[6]; //0,0,0,0,0,0
     //a:源数组
     //1:源数组的起始下标
     //b:目标数组
     //0:目标数组的起始下标
     //4:要复制的元素个数
     System.arraycopy(a,1,b,0,4); //灵活性好
     for(int i=0;i<b.length;i++){
         System.out.println(b[i]);
     }

方法2：
可以给数组扩容缩容

     int[] a = {10,20,30,40,50};
     //a:源数组
     //b:目标数组
     //6:目标数组的长度
     //  --若目标数组长度>源数组长度，则末尾补默认值
     //  --若目标数组长度<源数组长度，则将末尾的截掉
     int[] b = Arrays.copyOf(a,6); //灵活性差

方法：函数、过程

作用：用于封装一段特定的业务逻辑功能

建议：尽可能独立，一个方法只干一件事

方法可以被反复多次调用

好处：可以减少代码重复，有利于代码维护

何时用：只要是一个独立的业务功能，就得封装到一个方法中

方法的定义：五要素

   修饰词  返回值类型  方法名(参数列表){
       方法体---------具体的业务逻辑功能实现
   }

   //无参无返回值
   public static void say(){
       System.out.println("大家好");
   }
   
   //有参无返回值
   public static void sayHi(String name){ //----------------------形参
       System.out.println("大家好");
   }
   
   //有参无返回值
   public static void sayHello(String name,int age){ //-----------形参
       if(age>=60){ //在某种特定条件下，提前结束方法
           return; //结束方法
       }
       System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
   }
   
   //无参有返回值
   public static double getNum(){
       //在有返回值的方法中，必须得通过return来返回数据
       //return; //编译错误，return后必须跟一个数据
       //return "abc"; //编译错误，return后数据的类型必须与返回值类型匹配
       return 8.88; //1)结束方法的执行  2)返回结果给调用方
   }

方法的调用
无返回值：方法名（有参传参）

     public static void main(String[] args) {
         say(); //调用say()方法
     
         //sayHi(); //编译错误，有参则必须传参
         //sayHi(250); //编译错误，参数类型必须匹配
         sayHi("zhangsan"); //String name="zhangsan" //-----实参
     }

有返回值：数据类型 变量 = 方法名（有参传参）

     public static void main(String[] args) {
         double a = getNum(); //getNum()的值就是return后的那个数
         System.out.println(a); //8.88---模拟对返回值的后续操作
     
         int b = plus(5,6);
         System.out.println(b); //11---模拟对返回值的后续操作
     
         int m=5,n=6;
         int c = plus(m,n); //传的是m,n里面的数
         System.out.println(c); //11---模拟对返回值的后续操作

return
作用1：结束方法的执行

作用2：返回结果给调用方

方法的重载
方法的签名：方法名+参数列表

发生在同一类中，方法名相同，参数列表不同

编译器在编译时会根据方法的签名自动绑定方法

     package day06;
     public class MethodDemo {
         public static void main(String[] args) {
             say(); //自动绑定无参show
             say("zhangsan"); //自动绑定String参的
             say("lisi",25); //自动绑定String+int参的
             //say(3.456); //编译错误，没有double参的say方法
         }
     
         //无参无返回值
         public static void say(){
             System.out.println("大家好，我叫WKJ，今年39岁了");
         }
     
         //有参无返回值
         public static void say(String name){ //-----------------形参
             System.out.println("大家好，我叫"+name+"，今年39岁了");
         }
         
         //有参无返回值
         public static void say(String name,int age){ //------形参
             if(age>=50){ //在某种特定条件下，提前结束方法
                 return; //结束方法的执行
             }
             System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
         }
     
         public static void say(int age) {} //正确的重载
         public static void say(int age,String name){} //正确的重载
         //public static int say(){ return 1; } //编译错误，重载与返回值类型无关
         //public static void say(String address) {} //编译错误，重载与参数名称无关

参数
形参：形式参数，定义方法的参数为形参

实参：实际参数，调用方法的参数为实参

总结

练习时用到过的方法：

    Scanner scan = new Scanner(System.in);//用户输入值得扫描器
    Random rand = new Random();//随机整数
    Arrays.sort(arr);//数组降序排列
    Arrays.toString;//查看数组内容
    \t------------水平制表位，固定占8位