Java基础（九层妖塔）

一、Java的执行过程

二、变量、标识符、数据单位、运算符以及基本数据类型

1、标识符名命规则：

 i、英文拉丁字母。
            ii、标识符只能采用美元$和下划线_，其他符号不可以，
            iii、阿拉伯数字0-9，数字作为开头为被识别为数字，所以数字不能放在开头。	
            iiii、标识符区分大小写
            iiiii、Java中预先编译好的标识符（关键字或者保留字）不能被重新定义
            iiiiii、驼峰标识，规范
            iiiiiii、表示符没有长度限制

String name  = null;
String Name = null;

2、数据存储单位

 i、比特（bit位）：数据运算得最小存储单位，
 ii、字节（byte）：数据最小的存储单位
 iii、1byte = 8bit
 iiii、KB、MB、GB、TB......PB、EB
 IIIII、1024byte = 1KB，1024KB=1MB，1024MB=1GB，1024GB=1TB

3、Java的基本数据类型

在Java中声明float时候需要在小数后面加f（F）

  System.out.println(  Byte.SIZE   ); //8
        System.out.println(  Byte.SIZE  ); //8
        System.out.println(Short.SIZE );  //16
        System.out.println( Integer.SIZE); //32
        System.out.println(  Long.SIZE);         //64
        System.out.println( Character.SIZE );     //16
        System.out.println(Float.SIZE );         //32
        System.out.println( Double.SIZE);        //64
------------------------------------------------------------------------------------
double  f = 2.0;
float g = 2.0f;
-------------------------------------------------------------------------------------
boolean: 1 bit (不是真正的数据类型，通常由编译器替换为int执行操作)
byte: 1 byte (8位)
short: 2 bytes (16位)
int: 4 bytes (32位)
long: 8 bytes (64位)
char: 2 bytes (16位，Unicode字符)
float: 4 bytes (32位，IEEE 754)
double: 8 bytes (64位，IEEE 754)

数据类型转换
i、小类型转换为大类型：Java会自动将小类型数据转换为大的类型，比如小箱子里面的东西放在大的箱子里面是没有问题的
ii、大类型转为小类型：需要强转换

//小类型转换为大类型数据
 byte b = 20;
        short i = b;
        int u = i;
        long h = u;
        float g = h;
        double n = g;
        System.out.println(n);
 /**
         * 将大类型数据转换为小类型数据，大箱子里面的东西放到小箱子里面放不下就要丢掉一部分
         *     就会导致精度丢失
         */
    long x = 1000000009;
       int xx = (int)x;
        System.out.println(xx);

4、运算符

运算符：运算符就是参与运算的符号
表达式：所谓表达式就是采用运算符和数据连接在一起形成符合Java语法规则得指令代码。

i、算术运算符：

二元运算符：两个元素参与运算得运算符 1+2
一元运算符：一个元素参与运算得运算符 ++自增 --，对于++放在前面就是先自增再进行赋值，放在后面就是先进行赋值再自增。–和++概念一样。

//二元运算符，其中表达式有结果，有结果就会有类型，
//在运算符中那个类型最大最后结果就返回那个类型。在运算中最小的使用类型为int
System.out.println(1+2); //3
        System.out.println(2-2); //0
        System.out.println(3*2); // 6
        System.out.println(4/2); //2
        System.out.println(1/2); //0  int类型就是int类型就不会有小数点
        System.out.println(1.0/2); //0.5   在运算符中那个类型最大结果就返回那个类型
        System.out.println(5%2); //1 取余，模运算
//最小运算类型解决方案
    byte b1 = 1;
        byte b2 =2;
        byte b3 = (byte)(b1+b2);
        System.out.println(b3);
------------------------------------------------------------------------------------
//一元运算符
    int i = 0;
        int j = i;
        i = i+1;
        System.out.println(j);  //0
        System.out.println(i);  //1
//使用一元运算符
  int i = 0;
        int j = i++;  
        System.out.println(j);  //0
        System.out.println(i);  //1
//对于++放在前面就是先自增再进行赋值，放在后面就是先进行赋值再自增。
int i = 0;
        int j = ++i;
        System.out.println(j);  //1
        System.out.println(i);  //1

ii、赋值运算符，比如：=，复合赋值运算符：+=，-=，*=，/=，%=。就是元素进行运算之后重新将值赋给自己，使用复合赋值运算符，那么数据得数据类型不会发生变化。

   byte i = 10;
        i += 20;
        System.out.println(i);  //30

iii、关系运算符：关系运算符就是比较两个数据之间的关系

//关系表达式的结果为boolean
//关系运算符表达式：元素1  关系表达式    元素2
 int i = 10;
        int j = 20;
          System.out.println(i==j);
        System.out.println(i != j);
        System.out.println(i<= j);
        System.out.println(i>=j);
        System.out.println(i<j);
        System.out.println(i>j);

iiii、逻辑运算符：逻辑运算符就是用于描述多个条件表达式之间的关系

短路与运算：会根据第一个表达式的结果来判断，是否执行第二个条件表达式
短路或运算：会根据第一个表达式的结果来判断，是否执行第二个条件表达式

基本结构语法：变量=（条件表达式1） 逻辑运算符  （条件表达式2）

  int i = 10;
        int j = 20;
        boolean re = (i<20) & (i>11);  //false
        boolean rr = (i<20) | (i>11);  //true
        System.out.println(re);
        System.out.println(rr);
------------------------------------------------------------------------------------
//短路与运算符
   int i = 10;
        int j = 20;
        boolean re = (i <9) && (++j>10);
        System.out.println(j);//20
        System.out.println(re);//false

   int i = 10;
        int j = 20;
        boolean re = (i >1) && (++j>20);
        System.out.println(j);//21
        System.out.println(re);//true
//短路或运算
  int i = 10;
        int j = 20;
        boolean re = (i >1) || (++j>20);
        System.out.println(j);//20
        System.out.println(re);//true

       int i = 10;
        int j = 20;
        boolean re = (i <1) || (++j>20);
        System.out.println(j);//21
        System.out.println(re);//true

iiiii、三元运算符：（关系表达式 ? 表达式1 ： 表达式2）

//当关系表达式为true将表达式1结果赋值给re，当关系表达式为false时将表达式2结果赋值给re
int i = 10;
        int j = 20;
        int  re = (i >11) ? ++j : --j;
        System.out.println(re);//19

       int i = 10;
        int j = 20;
        int  re = (i <11) ? ++j : --j;
        System.out.println(re);//21

5、流程控制

流程控制就是指计算机在执行代码时，对指令代码执行顺序的控制
Java流程控制分为三种

1、顺序执行

        int i = 10;
        int j = 20;
        System.out.println(i+j); //30

2、分支执行：指在执行过程中有很多种选择的路线，通过判断走那一个流程。

switch语法会对数据进行判断，如果等于某一个分支数据的值，那么执行对应分支的逻辑代码
如果一个分支都无法匹配，那么一个分支都都不会执行，如果想要无法匹配也需要执行分支，那么可以增加default关键字。
如果执行匹配到分支后通过break跳出switch循环。

     System.out.println("第一步");
        System.out.println("第二步");
        int i = 10;
        switch(i){
            case 10:
                System.out.println("分支1");
            case 20:
                System.out.println("分支2");
            case 30:
                System.out.println("分支3");
        }
        System.out.println("第三步");
运行结果：
第一步
第二步
分支1
分支2
分支3
第三步
--------------------------------------------------------------------------------------
   System.out.println("第一步");
        System.out.println("第二步");
        int i = 30;
        switch(i){
            case 10:
                System.out.println("分支1");
            case 20:
                System.out.println("分支2");
            case 30:
                System.out.println("分支3");
        }
        System.out.println("第三步");
运行结果：
第一步
第二步
分支3
第三步
------------------------------------default--------------------------------------------------
default：
   System.out.println("第一步");
        System.out.println("第二步");
        int i = 0;
        switch(i){
            case 10:
                System.out.println("分支1");
            case 20:
                System.out.println("分支2");
            case 30:
                System.out.println("分支3");
            default:
                System.out.println("其他分支");
        }
        System.out.println("第三步");
运行结果：
第一步
第二步
其他分支
第三步
---------------------------跳过其他分支--------------------------------------------
 System.out.println("第一步");
        System.out.println("第二步");
        int i = 10;
        switch(i){
            case 10:
                System.out.println("分支1");
                break;
            case 20:
                System.out.println("分支2");
            case 30:
                System.out.println("分支3");
            default:
                System.out.println("其他分支");
        }
        System.out.println("第三步");
运行结果：
第一步
第二步
分支1
第三步

3、重复执行(循环执行)根据条件循环执行

Java用于循环的语法有三个：

i、while：有条件循环（如果条件表达式为true则会执行代码块，执行完代码块之后再去对条件表达式判断）

while(条件表达式){循环执行代码}  //如果条件表达式为true则会执行代码块，
                                 //执行完代码块之后再去对条件表达式判断
------------------------------------------------------------------------------------
   System.out.println("第一步");
        int i = 20;
        while(i<21){
            System.out.println("heieih");
            ++i;
            System.out.println(i);
        }
        System.out.println("第二步");
运行结果：
第一步
heieih
21
第二步

ii、do…while：将条件判断放在后面，先执行循环代码再判断，至少会执行一次

//基本语法结果
do{
    //循环代码
}while(条件表达式)
------------------------------------------------------------------------------------
         System.out.println("第一步");
        int i = 20;
        do {
            System.out.println("hshshhshsh");
        }while(i >30);
        System.out.println("第er步");
运行结果：
第一步
hshshhshsh
第er步

iii、for：如果条件表达式为true执行循环代码，如果为false则跳出循环。

基本语法：
for(初始化表达式;条件表达式;更新表达式){

    循环代码
}
-------------------------------------------------------------------------------------
 System.out.println("第一步");
        int i = 20;
        for (;i<19;){
            System.out.println("循环代码");
        }
        System.out.println("第二步");
运行结果：
第一步
第二步
----------------------------------------------------------------------------------------
   System.out.println("第一步");

        for (int i=18;i<20;i++){
            System.out.println("循环代码");
        }
        System.out.println("第二步");
运行结果：
第一步
循环代码
循环代码
第二步
---------------------------------break跳出循环--------------------------------------
    System.out.println("第一步");
        for (int i = 0; i < 10; i++) {
            if (i==4){
                break;
            }
            System.out.println(i);
        }
        System.out.println("第二步");
运行结果：
第一步
0
1
2
3
第二步
------------------------continue跳过当前循环，继续后续循环----------------------------------------------------
  System.out.println("第一步");
        for (int i = 0; i < 10; i++) {
            if (i==4){
                continue;
            }
            System.out.println(i);
        }
        System.out.println("第二步");
运行结果：
第一步
0
1
2
3
5
6
7
8
9
第二步

小练习：九层妖塔

--------------------------第一个方法：打印三层------------------------------------------------------
     for (int i = 0; i < 1; i++) {
            System.out.print("*");
        }
        System.out.println("");
        for (int i = 0; i <2 ; i++) {
            System.out.print("*");
        }
        System.out.println("");
        for (int i = 0; i < 3; i++) {
            System.out.print("*");
        }
运行结果：
*
**
***
----------------------第二个方法：九层-------------------------------------------
       for (int i = 0; i < 9; i++) {
            for (int j = 0; j < i+1; j++) {
                System.out.print("*");
            }
            System.out.println("");
        }
运行结果：
*
**
***
****
*****
******
*******
********
*********
-------------------------打印1 3 5 7 9层-------------------------------------------
     int sum = 5;
        for (int i = 0; i < sum; i++) {
            for (int h = 0; h < (sum-1)-i; h++) {
                System.out.print(" ");
            }
            for (int j = 0; j < i*2+1; j++) {
                System.out.print("*");
            }
            System.out.println("");
        }
运行结果：
    *
   ***
  *****
 *******
*********

三、面向对象

1、基础语法

（1）、面向对象：分析问题时候，以问题涉及到的对象（事和物）为中心的分析方式。

（2）、类和对象：类就是归纳和整理，对象就是具体的事物

---------------------------------类-----------------------------------------------
class 类名{
    特征（属性）
    功能（方法）
}
--------------------------------------------------------------------------------
使用类的步骤：
top1：先声明类
top2：创建对象
     new 类名();  每次new出来的对象，都是一个全新的对象，使用一次创建一次
top3：声明属性，就是类中的变量
      变量类型 变量名称 = 变量值
      属性类型 属性名称 = 属性值
top4：声明方法，void 方法名(参数){功能代码};
top5：执行方法。
      对象.方法名();

/**
 * @ProjectName: study01
 * @Package: study01
 * @ClassName: JavaCooking
 * @Author: TianLong
 * @Description:
 * @Date: 2024/7/6 19:51
 * @Version: 1.0
 */
public class JavaCooking {
    public static void main(String[] args) {
        Cooking c = new Cooking();
        c.name = "红烧排骨";
        c.food = "排骨";
        c.execute();
    }
}
class Cooking{
    String name;
    String type = "红烧";
    String food;
    String relish = "大料";

    void execute(){
        System.out.println("准备食材："+food);
        System.out.println("准备佐料："+relish);
        System.out.println("开始烹饪");
        System.out.println(name+"烹饪完成");
    }
}
运行结果：	
准备食材：排骨
准备佐料：大料
开始烹饪
红烧排骨烹饪完成

类、对象以及变量区别：基本数据类型是存储在栈中。
对象：对象是将内存中的地址赋值给了变量，所以变量其实引用了内存中的对象，所以称之为引用变量，类型称之
为引用数据类型。
特殊对象：空对象，没有引用的对象，称之为空对象（关键字对象）。User user = null;
注意：所有类型变量的默认取值都是null。
三块不同区域的内存区域

（3）、面向对象-属性

属性：就是类的对象的相同特征，语法和变量的声明很像，变量只能在方法内使用，属性可以随着类的对象在其 他地方使用，变量必须初始化，属性可以不初始化，因为jvm会帮助我们自动初始化。
属性类型 属性名称 = 属性值；
比如：String str;
属性会在构造对象的时候进行默认初始化，默认值取决于属性类型。

（4）面向对象方法

i、声明的语法：void 方法名(){ //逻辑代码 } 这里的void表示方法没有结果，

ii、有结果的返回：比如返回一个List，声明的语法 List 方法名(参数){}

package study01;

public class Java_math {
    public static void main(String[] args) {
        User user = new User();
        boolean register = user.message();

        if (register){
            System.out.println("注册成功！！");
            boolean login01 = user.login();
            if (login01){
                System.out.println("登录成功");
            }else {
                System.out.println("登录失败");
            }
        }else {
            System.out.println("注册失败");
        }
    }

    static class User{
        boolean  message(){
            System.out.println("用户注册");
            return true;
        }

        boolean  login(){
            System.out.println("用户登录");
            return false;
        }
    }
}

结果：
用户注册
注册成功！！
用户登录
登录失败

iii、方法参数

方法参数：使用外部变量来操作内部方法实现的变量
注意：
1、参数类型匹配，
2、参数个数匹配
3、参数顺序匹配
4、当参数的个数不确定，但是类型相同时，可以采用特殊的参数语法声明，可变参数
语法：String… 参数名称，如果有其他确定参数时候，可变参数必须放在最后。

   void test(String... name){
        System.out.println(name[0]);
    }

    public static void main(String[] args) {
        new Java_math().test();
        new Java_math().test("王五"); 
        new Java_math().test("王五","张三","李白");
    }
----------------------------------如果有其他确定参数时候，可变参数必须放在最后-----------
    void test(int sum,String... name){
        System.out.println(name[1]);
    }

    public static void main(String[] args) {
        new Java_math().test(1);
        new Java_math().test(1,"王五");
        new Java_math().test(1,"王五","张三","李白");
    }

（5）参数在底层是如何传递的

Java中方法参数的传递为值传递
基本数据类型传递的是数值
引用数据类型传递的是引用地址

    public static void main(String[] args) {
        int i = 10;
       test(i);
        System.out.println(i);//10
    }

    public static void test(int i){
        i=i+10;
        System.out.println(i); //20

    }
--------------------------引用数据类型传递参数----------------------------------------------
    public static void main(String[] args) {
        String i = "abc";
       test(i);
        System.out.println(i); //abc
    }

    public static void test(String i){
        i=i+10;
        System.out.println(i);//abc10

    }

----------------------引用数据类型-------------------------------------------------------
    public static void main(String[] args) {
        User user = new User();
        user.name = "zhangsan";
       test(user);
        System.out.println(user.name); //lisi
    }
    public static void test(User user){
        user.name = "lisi";
    }
    static class User{
        String name;
    }

注意：基本数据类型是放在栈中的，引用数据类型放在堆里面。

（6）、面向对象-静态

对象：针对具体对象的属性称之为对象属性、成员属性、实例属性
方法：针对具体对象的方法称之为对象方法，成员方法，实例方法

    public static void main(String[] args) {
        Chinese chinese = new Chinese();
        chinese.name = "zhangsan";
        System.out.println("hello "+ chinese.name+","+chinese.nationality);
    }
    
  static class Chinese {
      String name;
      String nationality = "中国";
  }

静态属性和静态方法

把和类相关的属性称之为静态属性，把和类相关的方法称之为静态方法，静态语法就是在属性和方法前面添加static关键字。

成员方法可以去访问静态属性和静态方法。静态方法不可以访问成员属性和成员方法

    public static void main(String[] args) {
        Bird.fly();
        System.out.println(Bird.name);//飞鸟

    }

class Bird{
      static String name = "飞鸟";
      static void fly(){
           System.out.println("飞");//飞
        }
    }

-----------静态方法可以直接通过类去访问也可以通过对象去访问------------------------------------------------------
    public static void main(String[] args) {
        Test test  = new Test();
        test.test();
        test.test01();
        Test.test01();

    }
    static class Test{
         String name;
         static String sex;

         void test(){
             System.out.println("test.............");
         }
        static void test01(){
            System.out.println("test01...............");
        }
    }

------------------------静态属性也可以通过对象去访问---------------------------------------
    public static void main(String[] args) {
        Test test  = new Test();
        test.sex = "女";
        test.test();

    }
    static class Test{
         String name;
         static String sex;

         void test(){
             Test.test01();   
             System.out.println(sex);
         }
        static void test01(){
            System.out.println("test01...............");
        }
    }
打印结果：
test01...............
女

静态代码块

类的信息加载完成之后会自动调用代码块，只要类被加载静态代码块就会被执行（可以完成静态属性的初始化）。
静态代码块可以有多个，必须按照创建的顺序执行。
对象在准备创建时，也会自动调用代码块，但不是静态的

-----------------------------类的信息加载完成之后会自动调用代码块--------------------------
public static void main(String[] args) {
        Test.test();
    }
    static class Test{
        static{
            //静态代码块
            System.out.println("静态代码块");
        }
        static void test(){
            System.out.println("test.................");
        }
    }
打印结果：

静态代码块
test.................

-----------------------------------静态代码块可以有多个，必须按照创建的顺序执行-------------
  public static void main(String[] args) {
       new Test();
    }
    static class Test{
        static{
            //静态代码块
            System.out.println("静态代码块");
        }
        static{
            //静态代码块
            System.out.println("静态代码块1");
        }
        static{
            //静态代码块
            System.out.println("静态代码块2");
        }
    }
运行结果：

静态代码块
静态代码块1
静态代码块2

------------------------------对象在准备创建时，也会自动调用代码块，但不是静态的-------------
    public static void main(String[] args) {
                new Test();     //构建对象
    }
    static class Test{
        {
            System.out.println("代码块2");
        }

        {
            System.out.println("代码块3");
        }
    }

运行结果：
代码块2
代码块3

（7）、面向对象-包和import

包：用于管理类
import：导入，如果同一个包中需要导入大量的类，那么可以使用通配符星号来简化操作

（8）、面向对象-构造方法

构造方法：专门用于构建对象
语法：类命(){}
i、构造方法没有void关键字，方法名和类名完全相同。
ii、如果类中没有构造方法那么jvm会提供默认的构造方法，如果类中有构造方法，那么jvm就不会提供默认的无参构造方法
iii、构造方法传递参数，一般用于对象属性的赋值
iiii、代码块是在构造对象之前执行的

    public static void main(String[] args) {
        User11 user11 = new User11();//这里的new User11()调用的就是构造方法
        user11.test();
    }

    static class User11{
        User11(){
            System.out.println("构造方法");
        }
        void test(){
            System.out.println("test1111111111");
        }
    }

打印结果：
构造方法
test1111111111

--------------------------------有参的构造方法--------------------------------------------
    public static void main(String[] args) {
        User11 user11 = new User11("zhangsan");
        System.out.println(user11.username);
    }

    static class User11{
        String username;
        User11(String username){
            this.username  = username;
            System.out.println("构造方法");
        }
    }

打印结果：
构造方法
zhangsan

--------------------代码块是在构造对象之前执行的--------------------------------------------
    public static void main(String[] args) {
        User11 user11 = new User11("zhangsan");
        System.out.println(user11.username);
    }

    static class User11{
        {
            System.out.println("代码块1");
        }
        String username;
        User11(String username){
            this.username  = username;
        }

        {
            System.out.println("代码块2");
        }
    }
执行结果：
代码块1
代码块2
zhangsan