JAVA小白学习日记Day1

吕秃秃

已于 2024-07-23 20:26:26 修改

阅读量417

点赞数 13

文章标签： java intellij-idea jvm

于 2024-07-15 08:12:22 首次发布

本文链接：https://blog.csdn.net/m0_63367052/article/details/140428626

版权

Day1日记

Java语言特点(跨平台★):一次编译到处执行,JVM

JDK安装与环境变量配置:JAVA_HOME Path javac(编译器) java

手撕HelloWorld

程序运行过程★★ 源码--javac--字节码文件---java---系统指令（通过jvm）

创建Java项目源文件夹 src 包

关键字系统中内定一些特殊含义的单词

标识符(规则和规范★)

变量常量 final 声明类型变量名初始化未初始化

数据类型★ 基本数据类型引用类型

基本数据类型的转换★ 隐式转换强制类型转换

输入输出 Scanner 注意close()

注释单行// 多行/**/ 文档注释/** */

运算符和表达式

算术运算符(前置后置★) +-*/% %正负号优先级 () =

比较运算符(==!=★) ==基本数据类型比较的是值

逻辑运算符(短路★) && || !

一、基础

Java跨平台的语言

Jdk --Java开发工具包，Java语言开发环境

Jre --Java程序运行环境

建议使用jdk 8

Jvm --Java程序的虚拟机

Jdk中包含jre，jre中包含jvm

配置环境

JAVA_HOME：jdk根路径

Path：系统执行文件地址

高级设置--环境变量--设置

Java--代码

指令：

Javac 编译指令，讲java文件编译成class文件（class文件也叫字节码文件）

Java 类名运行指定类 jvm解析字节码文件编程系统（wins）指令

Java跨平台（一次编译到处执行）

Jvm将字节码内容解析成系统执行和系统交互，在不同系统上安装不同版本的虚拟机，执行字节码文件

利用java虚拟机为媒介传递

创建项目

Src：源文件夹，java代码

注释：

// 单行

/* 注释内容 */ 多行

/** */ 文档注释

Class 类名{} 类结构

一个.java文件中只能有一个public类且这个外部类类名必须与文件名一致

关键字：

开发语言中内定的一些单词，赋予了一些特定的作用，开发人员不得随意使用java中关键字所有字母都是小写且无特殊字符

标识符：

变量名，类名，方法名，参数名，常量名等

命名规范：只能由字母，数字，$和_组成，首字符不能是数字（中文，语法上通过，但行业不允许）

标识符不能是关键字（可包含）

常量名：全部大写

其他：

尽量使用驼峰命名法（单词首字母大写）

所有的标识符都要见名知意，可以缩写，如果影响到见名知意就不要缩写

变量：在程序运行阶段可以发生变化的量

声明变量：
声明变量的名字和类型，例如int a，声明整数类型变量a，a之能存储整数型的值；a=1，给变量赋值

初始化：给变量第一次赋值，int a=1；

未初始化：没有给变量赋值（该变量不可使用）

常量：在程序运行阶段不可以发生变化的量

final int a=0;

基本数据类型

整数类型：byte short int long

浮点型：float double

字符型：char

布尔型：boolean

整数类型取值范围：默认值为0

Byte：1个字节，一个byte里有八个bit，一位符号加七位数（01），符号位0正1负 -2^7~2^7-1 -128~127 （负数二进制算值要反码加一，将第一位符号位提出了，剩下取反码，再加一）

Short：两个字节，十六个二进制，-2^15~2^15-1

Int（默认类型）：四个字节，三十二个二进制，-2^31~2^31-1

Long：八个字节，六十四个二进制，-2^63~2^63-1（记录时间是一毫秒加一，一千毫秒=一秒）

Float：单精度浮点型，四个字节，默认值0.0f

Double（默认类型）：双精度浮点型，八个字节，默认值0.0

Char：两个字节，0~65535 （FFFF）只能表示一个字符，三种定义，0000是16进制

Boolean：1或4个字节（数组时是四个字节）默认是0（false）且Boolean不能与其他类型转换，强制转换也不行

引用数据类型（除了基本的）

基本数据类型转换

隐式转换（程序自动完成）：

取值范围小的自动转换成取值范围大的类型的值

强制类型转换：

一刀切

整数与字符间转换：

\n：新行

\r：回车

\t：制表

\\：第一个转义符，第二个\

\是转义符，空格不需要

0b二进制，0八进制，0x十六进制

println（）可空，且会换行，print（）不能为空且不换行

Scanner scan=new Scanner(System.in);

扫描器输入流对象

scan.close();

进行输入流之后要关闭

运算符：

+-*/%

整数与整数运算的结果为整数（注意：除法），除非有long参与运算，结果为long，

%的结果正负，a%b的结果正负号与a一样

a=10 b=a++

a++：先将a的值付给b，a再加一，b=10，a=11

-：先将a的值付给b，a再减一，b=10，a=9

++a：先a+1，再将a付给b，b=11，a=11

- -a：先a-1，再将a付给b，b=9，a=9

优先级：（）*/% +- =

比较运算符：

> >= < <= == != 得到的结果是boolean类型

==在基本数据类型那个中比较的是值是否一样，与类型无关

逻辑运算符：

&&：逻辑与运算符 a&&b，a和b都为true，结果为true

||：逻辑或运算符 a||b，a或b有一个为true，结果为true

！：逻辑非运算符！true，结果为flase

短路现象：多个表达式运算，前面的表达式已经可以明确整个表达式的结果，后面的就不用运行了

a已经明确了，所有后面b没有运算，b的结果是0

package com.text;

public class TextD {
    public static void main(String[] args) {
        //运算符
        int result = 12 & 3;
        System.out.println(result);//结果：0
        //按位与运算  &  A&B
        //将A和B转成二进制，右侧对其，上下比较，两者都为1，结果才为1，否则为0，最后转换成十进制得到结果
        result = 12 & 11;
        System.out.println(result);//结果：8
        //按位或运算  |  A|B
        result = 12 | 11;
        //两者有一个为1，结果就为1，两者全为0，结果才为0
        System.out.println(result);//结果：15
        //按位异或运算
        result = 12 ^ 11;
        //两者转成二进制，右侧对其，上下比较，两者不同则为1，相同则为0
        System.out.println(result);//结果：7
        //反码运算
        result = ~11;
        System.out.println(result);//结果：-12
        //反码   ~   将二进制中的0换1，1换0
        //移位运算    <<   向左移位，放大    >>   向右移位，缩小
        result = 1<<2;
        System.out.println(result);//结果：4
        result = -1>>2;
        //向右移位左侧补符号位
        System.out.println(result);//结果：-1
        result = 3>>1;
        System.out.println(result);//结果：1
        //   >>>   空出来的位置补0
        System.out.println(Integer.MAX_VALUE);//2147483647
        result = -1>>>1;
        System.out.println(result);//2147483647
        //   &   |  也可以对boolean值运算，得到boolean值
        boolean bool = true & false;//  & 和&&运算结果一样，运算过程不一样
        int a=12,b=12;
        bool = a++<12&b++>12;//将a和b的值转成二进制然后比较
        bool = a++<12&&b++>12;
        // & 与 &&的不同：&是位运算符，&&是逻辑运算符 ，&不具有短路效果，即左边false，右边还会执行；&&具有短路效果，左边为false，右边则不执行

        //赋值运算   =  +=  -=  *=  /=  %=
        a=12;
        a+=2;//和a=a+2不一样，只是int可以，byte类型就不行
        a-=2;
        a*=2;
        a/=2;
        a%=2;

        //三元运算   A？B：C  A是boolean类型，A是true，取B，是false，取C
        int result1=true?11:22;
        System.out.println(result1);
        result1=12.3!=48?'b':322;//这种形式也可以

        //练习
        System.out.println(true?3:4.0);//结果是3.0  有double类型参与要用double

    }
}

package com.text;

public class TextE {
    public static void main(String[] args) {
        //流程控制
        int score = 87;
        if (score >= 60) {
            System.out.println("及格了");
        } else {
            System.out.println("不及格");
        }//必须以if开头，不能只写else

        //switch case
        //匹配某一个变量的值，如果匹配到某一个case的项，就从这个case开始运行
        //运行到break或者代码块结束
        //所有的case项都没有匹配成功，会执行default
        //case项和default项的顺序可以打乱
        //switch可以匹配的类型char, byte, short, int, Enum（枚举），String
        int num = 2;
        switch (num) {
            case 1:
                System.out.println("春");
                break;
            case 2:
                System.out.println("夏");
                break;
            case 3:
                System.out.println("秋");
                break;
            case 4:
                System.out.println("冬");
                break;//如果不加break，会从2（夏）开始一直到4（冬）运行到代码块结束，输出夏秋冬
            default:
                System.out.println("季节");
        }
        //循环
        //while (继续循环的条件){
        //    循环体
        //}
//        int i='a';
//        while (i<'e'){
//            System.out.println((char)i);
//            i++;
//        }
        //do...while至少执行一次，先执行后判断
//        do {
//        }while();

        //for循环
//        for(;;){
//            //无限（死）循环
//        }
        for (int n = 0; n < 10; n++) {
            System.out.println(1 + n);
        }
//
        Math.random();//[0,1）随机数
        int cat = 100;
        int count = 0;
        int mouse = (int) (Math.random() * 120);
        while (cat > mouse) {
            count++;
            mouse = (int) (Math.random() * 120);
        }
        System.out.println("猫抓了" + count + "只老鼠。");
        int num1 = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 3 == 0) {
                num1 += i;
            }
        }
        System.out.println(num1);
        //break 直接跳出循环体   confinue结束当前一次循环，开始下一次循环
        for (int aa = 1; aa < 10; aa++) {
            if (aa % 7 == 0) {
//                break;
                continue;
            }
            System.out.println(aa);
        }
//        boolean bool=true;
//        easy:for (;;){
//            for (;;){
//                for (int bb=0;bb<100;bb++)
//                {
//                    if (bb%5==0)
//                    {
//                        break easy;//通过easy来使break跳出多重循环
//                    }
//                    System.out.println(bb);
//                }
//            }
//        }
        //死循环  没有循环结束的条件，之后不能写其他代码
        //无限循环  结束循环的条件永远达不到，可以编写其他代码
//        while (true){
//      }死循环
//        a=0;
//        while(a<100){a--}无限循环
        //死循环会直接报错，无限循环默认有条件可以循环

    }
}

package com.text;

import java.util.Arrays;
import java.util.Scanner;

public class TextF {
    public static void main(String[] args) {
        //练习
        /*Scanner scan=new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score=scan.nextInt();
        if (score>=85){
            System.out.println("成绩优秀");
        }else if(score>=70){
            System.out.println("成绩良好");
        }else if(score>=60){
            System.out.println("成绩及格");
        }else {
            System.out.println("成绩不及格");
        }
        System.out.println("---------------------");
        System.out.println("请输入月份：");
        int num=scan.nextInt();
        switch (num){
            case 1:
            case 2:
            case 3:
                System.out.println("春");
                break;
            case 4:
            case 5:
            case 6:
                System.out.println("夏");
                break;
            case 7:
            case 8:
            case 9:
                System.out.println("秋");
                break;
            case 10:
            case 11:
            case 12:
                System.out.println("冬");
                break;
            default:
                System.out.println("月份错误");
        }
        scan.close();*/
        //数组
        //定义
        int[] arr={1,2,3,4};
        int[] arrB=new int[]{1,2,3};
        //这两种是静态的
        int[] arrA=new int[4];//通过长度定义数组  【4】代表可以存放四个元素
        //这是动态的
        //数组的限定
        //1.只能存放指定类型的数据
        //2.数组的长度是不可变的
        //使用数组的元素    下标  从0开始依次增加
        System.out.println(arr[3]);//结果：4
        System.out.println(arr);//显示数组的地址
        arr[0]=99;//给数组元素赋值
        System.out.println(Arrays.toString(arr));//将数组转化成字符串打印
        //获取数组长度
        System.out.println(arr.length);
        //打印出arr数组中所有元素
        for (int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

        //二维数组  将一维数组中的元素变成一维数组
        int[][] arrs=new int[4][3];
        arrs[0][1]=12;
        System.out.println(Arrays.deepToString(arrs));
        //二维数组的限定   一维数组的个数不可变（比如上述arrs的【4】)也就是大的数组个数不可变
        arrs[2]=new int[]{1,2,3,4};
        System.out.println(Arrays.deepToString(arrs));
        //声明一个二维数组  使用随机数为每个元素赋值
        int[][] arrC=new int[5][4];
        for (int i=0;i<arrC.length;i++){
            System.out.println(Arrays.toString(arrC[i]));
            for (int j=0;j<arrC[i].length;j++){
                arrC[i][j]=(int)(Math.random()*100);
            }
            System.out.println(Arrays.toString(arrC[i]));
        }
        System.out.println(Arrays.deepToString(arrC));

        //数组下标越界
        arr=new int[4];
        System.out.println(Arrays.toString(arr));
        arr[2]=9;
//        arr[4]=11;报错越界


    }
}