JAVA基础语法一遍过

// 主类型只能有一个，必须与文件名相同
public class Hello {
	// 定义一个主方法
	public static void main(String[] args) {
		System.out.println("Hello world!第一个JAVA程序！");
        

        System.out.println("1.基本DOS指令：");
		// dir:查看当前目录文件（可用绝对路径）
		// cd..切换到其他盘（cd /D c:）
		// 切换到当前盘的其他目录（可用相对路径，..表示上一级）
		// 切换到根目录,cd D/
		// tree:查看当前目录树
		// cls：清屏
		// exit：退出
		// md:创建目录到指定位置
		// rd删除目录
		// copy:拷贝文件
		// del:删除文件
		// echo:输入内容到文件
		// move:剪切


        System.out.println("2.代码的注释方法");
        // 单行注释

        /*多行代码注释
        用此种方法*/

        // java Doc文档注释,可被以JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的程序说明文档，一般写在类
        // 标签是有规定的，@author 作者，@version 版本
        /**
 	        * @author Kickflip
 	        * @version 1.0
        */
        // 在cmd中以"javadoc -d 文档生成的文件夹名 -xx -yy 程序名.java"生成网页文档文件


        System.out.println("3.基本数据类与运算符：");
		// 整数型：
		byte a = 127;// 占1byte,-128~127
		short b = 100;// 占2byte
		int c = 100;// 占4byte
		long d = 100L;// 占8byte
		// 整形默认为int型，long需要在其后边加l或L

		// 浮点数型：
		float e = 127.5f;// 占4byte
		double f = 137.5;// 占8byte
		// 浮点数型 = 符号位 + 指数为 + 尾数位
		// 浮点型常量默认为double型,float型需要在其后边在f或F
		// .520等价于0.520,512e2等价于512*10^2
		// 计算得到的浮点数是以精度表示保存的，相等判断应该以差值的绝对值判断

		// 字符型(本质是以整数存储，可运算)：
		char c1 = 'a';
		char c2 = '\t';
		char c3 = '汉';
		char c4 = 97;

		System.out.println(c4); //输出a
		System.out.println((int)c4); //输出97
	
		// 布尔类型，值只能为true或false:
		boolean ispass = true;
		boolean notpass = false;

		// 数据类型的自动转换：
		// 多种数据类型运算时，全部数据类型将自动转换成精度最大的那种数据类型，再计算
		// 不能把精度大的数据类型赋值给精度小的数据类型，将精度小的数据类型赋值给精度大的数据类型时，会自动转换成精度大的数据类型
		// (byte，short)与char之间不会相互自动转换
		// char byte short三者中任一一个在参与计算时，会自动转换成int型
		// boolean类型不参与数据类型的自动转换
		// 运算结果的类型为操作数中精度最大的数据类型

		// 数据类型的强制转换(自动转换的逆过程，可能会造成精度损失或数据溢出)：
		// 强制转换只针对最近的操作数有效，应用小括号提升优先级
		// char可以保存int常量，不能保存int变量，应该强制转换int为char型再赋值

		// 基本数据类型转String：
		// 直接 + ""
		int num1 = 123;
		String s1 = num1 + "";

		// String转基本数据类型：
		// 使用基本数据类型对应的包装类的相应方法
		String s2 = "123";
		int num2 = Integer.parseInt(s2);
		float num3 = Float.parseFloat(s2);
		double num4 = Double.parseDouble(s2);

        
        System.out.println(-10%3);// -1
		System.out.println(10%-3);// 1
		System.out.println(-10%-3)// -1
		// 取模运算的本质：a%b == a - a/b*b；
		// 若a为浮点型：a%b == a - (int)a/b*b;
	
		int i = 1;
		i = i++;// 规则：temp = i;i = i+1;i = temp;
		System.out.println(i);// 1

		i = 1;
		i = ++i;// 规则：i = i+1;temp = i;i = temp;
		System.out.println(i)// 2


        int maxNum = 1222;  // 小驼峰
        // 类取名为大驼峰

        num2 += 11;// 隐含了强制类型转换，等同于num2 = short(num2 + 11);
        //num2 = num2 + 11;// 会报错,num2 + 11转化为了为int型

        int sex1 = -4,sex2 = -4;
        sex1 = sex1>>1;     //有符号右移，符号位不动，低位溢出，正数高位补0，负数高位补1

        sex2 = sex2>>>1;    //无符号右移，低位溢出，正负数高位都补0

        sex2 = sex2<<2;     //左移，符号位不动，高位溢出，低位补0


        System.out.println("4.循环语句:");
        for(int i=0;i<10;i++) {
            System.out.print("hello world!");
        }

        int count = 10;
        while(count>0)
        {
            System.out.println("hello world!");
            count--;
        }

        do{
            paper *=2;
            count++;
        }while(paper < 8844430);

    

        System.out.println("5.数组：");
        //动态初始化（确定长度，分配空间，自动赋初值）
        int score[];//或int[] score;
        score = new int[3];
        //或
        int[] arr1 = new int[3];

        int[][] arr12 = new int[3][2];

        //静态初始化（指定每个元素的值，由系统决定数组长度）
        int[] score1;
        score1 = new int[] {1,2,5};
        //或
        int[] arr2 = {1,2,5};   //同样的会申请一块堆内存

        int[][] arr22 = new int[][] {
                {1,324,543},
                {32,435,2,23452,54},
                {23,324,1423}
        };

        //访问数组(输出地址)
        System.out.println(score);

        //访问数组的元素
        for(int i=0;i<3;i++)
            System.out.println(score[i]);

        int[] nums = new int[3];
        System.out.println("addr:" + nums);
        //分配了sizeof(int)*3大小的堆内存，nums指向分配的内存地址，nums本身也占据一块栈内存
        //nums为局部变量，存在于栈内存中，使用完毕即消失
        //new出来的内容（实体，对象）存储在堆内存中，使用完毕，会在垃圾回收器空闲时被回收
        //java会自动为数组元素赋初值

        int[] arr = nums;   //两数组指向同一块堆内存

        for(int i=0;i<arr.length;i++)       //数组名.length可获得数组长度
            System.out.println(arr[i]);


        System.out.println("6.方法：");
        //在main中调用方法(在栈内存中申请空间)
        fangFa();//不带参数则不传递参数

        getMax(5,2);//传递实参（常量）

        int m=4,n=3;
        getMax(m,n);//传递实参（变量）

        byte q=7;//可将精度小的实参传给精度大的形参，反之则不可以
        getMax(m,q);

        //引用调用(形参变化影响实参变化)
        change(arr);
        for(int i=0;i<arr.length;i++)
            System.out.println(arr[i]);

        
	}
}

//其他类型数目不限
class dog{
	public static void main(String[] args) {
		System.out.println("Hello dog!");
	}
}

//定义一个方法（不能嵌套定义），static方法只能访问static变量
    //不带参数
    public static void fangFa(){
        int num = 250;
        System.out.println("这是一个方法");
    }

    //带参数，为形参，在栈内存中
    public static void getMax(int a,int b){
        System.out.println("第1个getMax方法");
        System.out.println(a>b?a:b + "=max");
        return;     //无返回值的方法也可return结束调用，但不可以包含值
    }

    //带返回值的方法
    public static int getMin(int a,int b){
        return a<b?a:b;
    }

    //方法重载(调用时JVM会根据传入实参的情况来决定调用哪个方法)
    // 1.在同一个类中
    // 2.具有相同的名称
    // 3.方法的参数类型或者数量不同(与返回值无关)
    public static int getMax(int a,double b){
        System.out.println("第2个getMax方法");
        return a>b?a:(int)b;
    }

    public static int getMax(int a,int b,int c){
        System.out.println("第3个getMax方法");
        return a>b&&a>c?a:b>c?b:c;
    }

    public static double getMax(double a,double b,double c) {
        return a>b&&a>c?a:b>c?b:c;
    }

    //可变参数个数的方法
    //1.数组的方式，没有参数也要传入一个null或者是空数组
    public static void printInfo(String[] args) {
        for(int i=0;i<args.length;i++)
            System.out.println(args[i]);
    }

    //2.JAVA特有的...方式，没有参数就可以不传，多个参数时，可变参数...必须写在最后边
    public static void printInfo2(String... args) {
        for(int i=0;i<args.length;i++)
            System.out.println(args[i]);
    }
    public static void getSum(int... nums)
    {
        for(int i=0;i<nums.length;i++)
            System.out.println(nums[i]);
    }
    public static void getSum(int asd,int... nums) {
        for(int i=0;i<nums.length;i++)
            System.out.println(nums[i]);
    }

    //引用型方法(形参变化影响实参变化),传入引用型参数
    public static void change(int[] arr) {
        arr[0] = 10086;
        arr[1] = 250;
        arr[2] = 502;
    }