java语法基础

import java.util.Scanner;

public class HelloWord {
    public static void main(String[] args) {
        var scanner = new Scanner(System.in);
        //int a = Integer.parseInt(scanner.nextLine());
        //int b = Integer.parseInt(scanner.nextLine());

        //1. 输入输出
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        System.out.println(a + b);

        //2.数据类型
        //简单数据类型 byte short int long float double boolean char
        byte c = 10;
        short d = 5;
        int e = 20;
        long f = 20;
        float g = 19.0234f;
        double h = 20.03434;
        boolean i = Boolean.getBoolean(String.valueOf(c + d));
        char j = 'j';
        System.out.println(c + d + e + f + g + h + j);
        if (i) {
            System.out.println("是真的");
        }

        //3.变量类型 RunTest
        //局部变量：定义在方法、构造方法或语句块中的变量，作用域为当前方法、构造方法或语句块，局部变量只能在使用前声明，不能被访问修饰修饰
        //成员变量：定义在类中，方法之外，作用域为整个类，可以被类中任何方法和语句块访问。可以被访问修饰符修饰
        //静态变量(类变量)：定义在类中，方法之外，使用static修饰，作用域为整个类，可以被类中任何方法和语句块访问。静态变量的值在程序运行期间只有一个副本。静态变量可以被访问修饰符修饰。
        /*参数变量（Parameters）：方法定义时声明的变量，作为调用该方法时传递给方法的值。参数变量的作用域只限于方法内部。
          值传递：值传递在方法调用时，方法定义时声明的变量传递的是实际参数的值的副本。当参数变量被赋予新的值时，只会修改副本的值，不会影响原始值。Java 中的基本数据类型都采用值传递方式传递参数变量的值。
          引用传递：在方法调用时，传递的是实际参数的引用（即内存地址）。当参数变量被赋予新的值时，会修改原始值的内容。Java 中的对象类型采用引用传递方式传递参数变量的值。*/
        RunTest runTest = new RunTest();
        runTest.method(20);
        runTest.method2();

        //4.java修饰符
        //访问控制修饰符：
        //default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
        //private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）可以修饰内部类
        //public : 对所有类可见。使用对象：类、接口、变量、方法
        //protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）可以修饰内部类。
        /*注意事项：
        Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类；
        接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public；
        类和接口不能声明为 private；
        类所有的公有方法和变量都能被其子类继承；
        接口及接口的成员变量和成员方法不能声明为 protected；
        子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
        子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。*///
        //非访问修饰符：
        //static 修饰符，用来修饰类方法和类变量。
        //final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
        //abstract 修饰符，用来创建抽象类和抽象方法。
        //synchronized 和 volatile 修饰符，主要用于线程的编程。
        //synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
        /*被 final 修饰的实例变量必须显式指定初始值。
          声明 final 方法的主要目的是防止该方法的内容被修改
          final 类不能被继承，没有类能够继承 final 类的任何特性
          一个类不能同时被 abstract 和 final 修饰
          如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
          抽象类可以包含抽象方法和非抽象方法。
          抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。抽象方法不能被声明成 final 和 static。
          任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
          如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
          抽象方法示例：public abstract sample();。*/
        //transient修饰符：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
        //volatile修饰符

        //5.java运算符
        //算术运算符：
        System.out.println(c+d);
        System.out.println(c-d);
        System.out.println(c*d);
        System.out.println(c/d--);
        System.out.println(d%++c);
        //++c先自加再运算 c--运算再自减
        //关系运算符：
        /*  == != > < >= <=  */
        if (a == b ) {
            System.out.println("a=b");
        }
        //位运算符：
        /*  & | ^ ~ << >> >>>   二进制按位运算 */
        //逻辑运算符：
        // &&逻辑与 当且仅当两个操作数都为真，条件才为真。
        // ||逻辑或 用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。
        // !逻辑非 用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。
        boolean num1 = Boolean.parseBoolean(scanner.nextLine());
        boolean num2 = Boolean.parseBoolean(scanner.nextLine());
        System.out.println("a && b = " + (num1&&num2));
        System.out.println("a || b = " + (num1||num2) );
        System.out.println("!(a && b) = " + !(num1 && num2));
        //赋值运算符：
        /*  = 简单的赋值运算符，将右操作数的值赋给左侧操作数
            += 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数
            -+ *= /=
            <<= >>=  左（右）移位赋值运算符
            &= |= ^= 按位与（或）（异或）赋值运算符*/
        //条件运算符（三元运算符）：
        String ifNum = num1 == num2 ? "是": "不是";
        System.out.println(ifNum);
        //instanceof 运算符: 该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
        String name = "dove";
        boolean result = name instanceof String;
        System.out.println(result);

    }
}


class RunTest {
    //成员变量
    private int instanceVar;
    //静态变量
    private static int staticVar;

    public void method(int paramVar) {
        //局部变量
        int localVar = 10;
        //使用变量
        instanceVar = localVar;
        staticVar = paramVar;
        System.out.println("成员变量：" + instanceVar);
        System.out.println("静态变量: " + staticVar);
        System.out.println("参数变量: " + paramVar);
        System.out.println("局部变量: " + localVar);
    }

    void method2() {
        //使用类名访问静态变量
        System.out.println(RunTest.staticVar);
        //使用对象访问成员变量  this指向当前类的对象
        System.out.println(this.instanceVar);
    }

}

import java.util.Scanner;

public class Study {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //6.java循环结构
        //while循环 只要布尔表达式为 true，循环就会一直执行下去。
        int x = 1;
        while (x < 5) {
            System.out.println("while循环");
            x++;
        }
        //do while循环 对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
        do {
            System.out.println("do while循环");
            x++;
        } while (x < 5);
        //for循环 虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。
        for (int i = 1, j = 2; i < 10; i++) {
            if (j < 8) {
                break; //使用break跳出循环
            }
            if (i == 5) {
                continue;//使用continue跳到下一次循环
            }
            System.out.println("for循环");
            i++;
        }
        //Java5 引入了一种主要用于数组的增强型 for 循环
        int[] nums = {10, 20, 30, 40, 50};
        for (int k : nums) {
            System.out.println(k);
            System.out.println(","); //10,20,30,40,50,
        }
        //7.条件语句  if语句可以嵌套
        int m = 10;
        if (m < 20) {
            System.out.print("这是 if 语句");
        }
        else{
            System.out.print("这是 else 语句");
        }

        //switch case
        var value = "value";
        switch(value){
            case "value" :
                System.out.println("对的");
                break;
            case "val" :
                System.out.println("不对");
                break;
            default :
                System.out.println("都不是");
        }
    }
}