Java基础知识学习笔记-12.1（待续）

Java基础知识
写在前面的话，会结合书上的例子以及面试过程中遇到的题目主要进行讨论，也欢迎大家指点批评，结合Java实践排位赛
使用软件及版本：
参考书：
参考视频：
数据类型：

               取值范围

byte: -128-127
short: -32768-32767
int
long
float
double
boolean
char:0-65535
关于八种数据类型的默认值：一切向0看齐
逻辑运算符：
&逻辑与（都真才真）
|逻辑或（有真就行）
！逻辑非（取反，单目运算符）
^逻辑异或（两边算子只要不一样，结果就是true）
&&短路与
||短路或
1、逻辑运算符要求两边算子都是布尔类型，并且逻辑运算最终的运算结果也是一个布尔类型
2、短路或与逻辑或最终结果相同，只不过存在短路现象
3、逻辑与与逻辑与最终结果相同，只不过存在短路现象
短路现象：逻辑判断整个表达式已经确定，不必要其他判定语句，短路，更加智能一些
赋值运算符
基本赋值运算符:=
扩展的赋值运算符：先执行等号右边，在赋值，扩展类的赋值运算符不改变运行结果类型，并且等同于强制类型转化符
+=、-=、*=、/=
byte i+=10；
i+=5；等同于i=（byte）（i+5）
编译错误，编译只检查语法，不考虑执行
字符串连接运算符
+的作用：
1、求和（两边全是数字）
2、字符串的连接运算（又一边是字符串，并且结果是字符串）

int a=10;
int b=20;
//以动态方式输出a+b的结果
system.out.printIn(a"+"+b+"="+(a+b));

引用类型string，字符串类型

//动态输出
int i=10;
String username="zhangsan"
system.out.printIn("登陆成功，欢迎"+username+"回来")

三目运算符
布尔表达式？表达式1：表达式2
真的表达1为表达式结果，假的表达2的结果为表达式结果

public class operator
{
   
   public static void main(string[] args){
   
      boolean sex=false;
      char c=sex?'男':'女'//主要两个表达式数据类型
      system.out.printIn(c)
      }
}

控制语句if

switch语句

for语句
练习题：99乘法表

public class ForTest08{
   
    public static void main(String[] args){
   
          for(int i=1;i<=9;i++){
   
             for(int j=1;j<=i;j++){
   
             System.out.printIn(i+"*"+j+"="+i*j+" ")
             }
             System.out.printIn();//换行
        }

    }
}

/* 1-100的素数 素数能够被1和自身整除，不能被其他数字整除的数字 */
public class ForTest09{
   
    public static void main(String[] args){
   
        for(int i=1;i<=100;i++){
   
           boolean isSuShu=true;
           for(int j=2;j<i;j++){
   
                  if(i%j==0){
   
                    isSuShu=false;
                    break;//提高效率
                  }
           }
         System.out.printIn(isSuShu?i+"是素数":i+"不是素数")
        }
    }
}
/* 升级版：1-10000,每8个换行 */
public class SuShu {
   
    public static void main(String args[]) {
   
        int count = 0;
        for (int i = 2; i <= 100; i++) {
   
            boolean isSuShu = true;
            for (int j = 2; j < i; j++) {
   
                if (i % j == 0) {
   
                    isSuShu = false;
                    break;
                }
            }
            if (isSuShu) {
   
                System.out.print(i + " ");
                count++;
                if (count % 8 == 0) {
   
                    System.out.println();
                }
            }
        }
    }
}

while语句
1、while语法结构：
while（布尔表达式）{

循环体；
}
2、执行原理：先判断布尔表达式的结果：
true执行循环体
false结束
3、循环次数：0-N次
4、特殊例子代码

public class WhileTest01{
   
    public static void main(String[] args){
   
    //死循环
    while(true){
   
        System.out.printIn("死循环")
        }
    }
}

注意编译期和运行期，写变量编译不会报错。
do while语句
1、语法结构：
do{

循环体；
}while(布尔表达式)；
2、执行原理：先执行循环体，在判断
3、执行次数：1-N次
4、注意事项：
do…while循环语句最终有“；”号，别丢了
break语句
1、中断、折断
2、switch和循环语句当中，终止
3、终止最近的循环语句，内存循环
continue语句
1、下面本次循环停止，下面语句不执行，直接进行下次循环

方法
1、某个功能代码只需要写一遍，要使用这个功能，只需要给这个功能传递具体的数据，提高复用性质，这就是方法
2、一段独立的代码片段，这段代码片段可以完成某个功能，并且可以重复使用
3、c语言叫做函数Functon
4、方法定义在类体中，方法体之外，方法体由java构成，自上而下构成
5、方法怎么定义：
[修饰符列表] 返回值类型 方法名 （形式参数列表） {

方法体；
}

public class MethodTest02 {
   
    public  static void main(String[] args){
   
        //计算两个int类型数据的和 
        MethodTest02.sumInt(10,20);

        MethodTest02.sumInt(666,888);

        MethodTest02.sumInt(111,222);
    }
    //单独的定义一个方法
    //该方法完成计算两个int类型数据的和，并且
    public static  void sumInt(int a,int b){
   
        int c=a+b;
        System.out.println(a+"+"+b+"="+c);
    }
}

5.1、关于修饰符列表：不必须
例如：public static
怎么调用:类名.方法名（实际参数列表）；
返回值类型是void的时候，在方法中不能编写return值；这样的语句，但是注意可以编写retuen；的语句，含有return关键字执行，return语句所在方法结束。
5.2、实参列表和形参列表：参数和类型对应相同
5.3、如果调用的方法和使用的方法在同一个类中，可以省略“类名.”
5.4、在返回值类型是void的方法中写return语句，不带返回值，编译可以成功，主要用来结束方法
5.5、返回值类型如果不是void必须有返回值，这个时候需要注意return的位置和写法
6、方法在执行过程中，在JVM中的内存是如何分配的，内存如何变化
6.1、方法定义不调用，不调用吗，是不会执行的，也不会分配内存空间
6.2、JVM内存划分主要三块内存空间：方法区内存，堆内存，栈内存
关于栈数据结构：栈，stack，是一种数据结构
数据结构反应了数据存储形态
栈顶元素（处于活跃状态，其他元素静置）、栈底元素、栈帧（永远指向栈顶元素）、
6.3.1、方法执行的时候，方法代码片段属于.class字节码一部分，字节码文件在加载的时候，将其放到了方法去当中，所以jvm的三块主要内存区方法去最先有数据，存放了代码片段，可以重复调用。
6.3.2每一次调用，需要重新活动场所，在栈内存中分配【栈内存中分配方法运行的所属内存空间】
6.3.3
压栈：方法在调用瞬间，会给该方法分配内存空间，会在栈中发生压栈动作
弹栈：方法执行结束后，会给该方法分配的内存空间全部释放掉，发生弹栈
6.3.4
局部变量在方法体中声明，局部变量在栈中存储，局部变量运行阶段内存在栈中分配。

7方法执行内存分析
7.1代码举例

//方法在调用的时候，传递的是变量中保存的值
//栈内存主要存的是局部变量
public class Methdoo1{
   
     public static void main(String[] args){
   
          int a=10;
          int b=20;
          int reValue=sumInt(a,b);
          System.out.printIn("reValue="+reValue);
     }
     public static int sumInt(int i,int j){
   
         int result=i+j;
         int num=3;
         int retValue=divide(result,num);
         return retValue;
     }
     public static int divide(int x,int y){
   
         int z=x/y;
         return z;
     }
}

8方法重载
8.1重载overload
8.1.1 不使用重载

//不使用方法重载
public class OverloadTest01 {
   
    //入口
    public static  void main(String[] args){
   
        //调用方法
        int result=sumInt(1,2);
        System.out.println(result);
        double result2=sumDouble(1.0,2.0);
        System.out.println(result2);
        long result3=sumLong(1L,2L);
        System.out.println(result3);
    }
    //定义一个方法，计算两个int类型的数据的和
    public static int sumInt(int a,int b){
   
        return a+b;
    }
    //定义一个方法，计算两个double类型的数据的和
    public static double sumDouble(double a,double b){
   
        return a+b;
    }
    //定义一个方法，计算两个long类型的数据的和
    public static long sumLong(long a,long b){
   
        return a+b;
    }
}

上述代码中方法不同，功能相似，都是求和，调用方法不方便，需要记忆更多的方法，才能完成调用，并且不美观，重载机制可以解决。javaScript不支持。
8.2.2 利用重载

public class OverloadTest02 {
   
    //入口，体验重载
    public static  void main(String[] args){
   
        //调用方法
        //参数的类型不同，对应调用的犯法不同
        //区别方法不在依靠方法名，依靠参数类型
        System.out.println(sum(1,2));
        System.out.println(sum(1.0,2.0));
        System.out.println(sum(1L,2L));
    }
    //定义一个方法，计算两个int类型的数据的和
    public static int sum(int a,int b){
   
        return a+b;
    }
    //定义一个方法，计算两个double类型的数据的和
    public static double sum(double a,double b){
   
        return a+b;
    }
    //定义一个方法，计算两个long类型的数据的和
    public static long sum(long a,long b){
   
        return a+b;
    }
}

8.3.3方法重载
（1）方法重载称为overload
（2）功能相似的时候，尽可能让方法名相同
（3）在同一个类当中，方法名相同，参数列表不同（数量不同，顺序不用，类型不同）
（4）方法重载和方法名，参数列表有关，与返回类型、修饰符列表无关
（5）具体应用

public class OverloadTest04 {
   
    //入口，体验重载
    public static  void main(String[] args){
   
        /*区别方法不在依靠方法名，依靠参数类型 System.out.println("Hello World"); System.out.println(10); System.out.println(true); */
        U.p(10);
        U.p(false);
        U.p("abc");
        U.p(3.0);
    }
}
class U {
   
    public static void p(byte b) {
   
        System.out.println(b);
    }
    public static void p(short b) {
   
        System.out.println(b);
    }
    public static void p(int b) {
   
        System.out.println(b);
    }
    public static void p(float b) {
   
        System.out.println(b);
    }
    public static void p(char b) {
   
        System.out.println(b);
    }
    public static void p(boolean b) {
   
        System.out.println(b);
    }
    public static void p(double b) {
   
        System.out.println(b);
    }
    public static void p(String b) {
   
        System.out.println(b);
    }
}

9方法递归调用
（1）什么是递归：方法自身调用自身，很耗费栈内存，能不用就不用
（2）递归必须有结束条件，没有结束条件一定会发生栈内存溢出错误
（3）递归太深了，即使结束条件正确，也可能会发生栈内存溢出
（4）利用递归求解问题：

public class RecursionTest03 {
   
         //递归方法求1-4和
    public static void main(String[] args){
   
        //1-4的和
        int n=4;
        int retValue=sum(n);
        System.out.println(retValue);
    }
    public static int sum(int n){
   
        if(n==1){
   
            return 1;
        }
        return n+sum(n-1);
    }
}

public class RecursionTest04 {
   
        //递归方法求n的阶乘
    public static void main(String[] args){
   
        //1-4的和
        int n=5;
        int retValue=method(n);
        System.out.println(retValue);
    }
    public static int method(int n){
   
        if(n==1){
   
            return 1;
        }
        return n*method(n-1);
    }
}