Java SE 基础入门知识

smobee

已于 2022-11-03 14:59:25 修改

阅读量127

点赞数

分类专栏： Java SE 文章标签： java

于 2022-10-28 23:57:20 首次发布

本文链接：https://blog.csdn.net/wg8ofk08/article/details/127581439

版权

Java SE 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

系列文章目录

提示：阅读本章之前，请先阅读目录

前言

本章用于Java SE的学习的记录，最基础

Hello world

安装

java jdk
vscode
配置好java环境变量

编写代码

public class Test {
    public static void main(String[] args) {
        System.out.print("Hello world!!!");
    }
}

运行

PS D:\java_code\test> javac .\Test.java
PS D:\java_code\test> java Test
Hello world!!!

注意事项

文件名要和class的类名一致
注意大小写

注释

public class Test {
    public static void main(String[] args) {
        System.out.print("Hello world!!!");
        // 单行注释
        /*
        多行注释
         */
        
        /**
         * 文档式注释
         */
    }
}

关键字

在这里插入图片描述

变量命名

public class Test {
    public static void main(String[] args) {
        // 以大小写字母开头 a~z A~Z 下划线_ $ 
        String abc = "1";
        String Abc = "2";
        String _abc123 = "3";
        String $abc123 = "4";
        // 也可以使用中文
        String 测试看看 = "ok";
        // 以下不合法
        String class = "使用关键字";
        String void = "使用关键字";
        String 123 = "使用数字开头";
        // 测试输出
        System.out.print(测试看看);
    }
}

强类型语言

public class demo01 {
    public static void main(String[] args) {
        // 尚未初始化变量a
        String a;
        System.out.printf(a);
        // 不兼容的类型: int无法转换为java.lang.String
        String a = 10;
        System.out.printf(a);
    }
}

八大数据类型

public class demo02 {
    public static void main(String [] args) {
        // 八大数据类型

        // 整数 byte short int long
        byte num1 = 127;
        short num2 = 12345;
        int num3 = 1234567899;
        long num4 = 1234567890987000006L; // long 类型的，要加L标识

        // 浮点数 float double
        float f1 = 1.25F;
        double f2 = 123456789.123466088888888888888888888;

        // 字符
        char c1 = '我';
        char c2 = '1';
        String c3 = "大家好啊"; // 要用双引号，String 不是关键字，而是类，大写字母开头，几乎都是类

        // 布尔 boolean
        boolean b1 = true;
        boolean b2 = false;
    }
}

字节类型和单位

1 bit = 1 位
1 byte = 1 字节
1 byte = 8 bit

1 B = 8 b
1024 B = 1 M
1024 M = 1 G
1024 G = 1 T

进制转换

public class demo03 {
    public static void main(String[] args) {
        // 8进制 0开头
        int num01 = 010;
        // 10进制 正常
        int num02 = 10;
        // 16进制 0x 开头 0~9 A~F  A为10，F为16
        int num03 = 0x10;
        System.out.println(num01);
        System.out.println(num02);
        System.out.println(num03);
    }
}

运行结果

8
10
16

完全避免使用浮点数进行比较运算

public class demo04 {
    public static void main(String[] args) {
        // float 有限 离散 舍入误差 大约 接近但不等于1
        // double
        // 最好完全避免浮点数进行比较
        // 最好完全避免浮点数进行比较
        // 最好完全避免浮点数进行比较
        // 可以使用BigDecimal工具类

        // 诡异比较，结果都是0.1，但是比较完结果为false
        float f1 = 0.1f;
        double f2 = 1.0/10;
        System.out.println(f1==f2);

        // 诡异比较，结果完全不一样，但是比较结果为true
        float d1 = 2333333333333333f;
        float d2 = d1 + 1;
        System.out.println(d2);
        System.out.println(d2==d1);

    }
}

运行结果

false
true
2.33333333E15

强制转换and转义字符

public class demo05 {
    public static void main(String[] args) {
        // 强制转换
        char c1 = 'A';
        char c2 = '我';
        System.out.println((int)c1);
        System.out.println((int)c2);
        // unicode 编码
        char c3 = '\u0055';
        System.out.println(c3);
        // 转义符
        System.out.println("大家好\t你好，我要换行了\n啊啊啊");
    }
}

运行结果

65
25105
U
大家好	你好，我要换行了
啊啊啊

字符比较实验，指针

public class demo06 {
    public static void main(String[] args) {
        // string 对象，不相同是因为指针的问题，这里创建了两个不同的对象
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1==s2);
        // string 因为已经被分配了一个对象，所以内容一样的话，其实是指向同一个指针地址
        String s3 = "hello";
        String s4 = "hello";
        System.out.println(s3==s4);
    }
}

运行结果

false
true

类型转换

在这里插入图片描述

public class demo07 {
    public static void main(String[] args) {
        /*
        规则一，不能对布尔值转换，原因是布尔值只有1位，1个字节=8位
        规则二，不能把对象类型转换为不相干的类型
        规则三，高容量转低容量，强制转换
        规则四，低容量转高容量，自动转换
        规则五，转换的时候，可能会存在内存溢出，或者精度问题
         */
        // 内存溢出的情况，高转低
        int i = 128; // byte最大是127
        byte c = (byte)i;
        System.out.println(c); // 输出-128
        // 低转高，自动转换
        int i1 = 1000;
        double d1 = i1;
        System.out.println(d1); // 输出1000.0
        // 精度问题
        System.out.println((int)1.23F); // 输出1
        System.out.println((int)45.1); // 输出45
        System.out.println((int)-45.123F); // 输出-45
        System.out.println((int)-45.123); // 输出-45
        // char和int相加
        char c3 = 'a';
        int i3 = c3 + 1;
        System.out.println(i3); // 输出98
        System.out.println((char)i3); // 输出b
        // JDK7新特性，数字太长时，可以用下划线区分，并且输出的时候不会带上
        int i4 = 10_0000_0000;
        System.out.println(i4); // 输出1000000000
        // 内存溢出，原因，超过int最大数值
        int year = 20;
        System.out.println(year*i4);// 输出-1474836480
        // 如果用long类型来接收结果，也是同样的会溢出，因为计算结果之前就已经存在问题
        long d3 = year*i4;
        System.out.println(d3);// 输出-1474836480
        // 解决内存溢出，可以对某个数值进行强制转换
        System.out.println((long)year*i4);// 输出20000000000
        // 在long类型的数据，大小写的L都可以表示，但是用小写的l，容易看错数字1，所以建议还是用大写L
        long l1 = 12345678111L; // 大写L
        long l2 = 12345678111l; // 小写L
    }
}

变量命名规范和作用域

在这里插入图片描述

public class Demo08 {
    // 初始化类的属性
    String s1 = "hello";
    int i1;
    // 定义常量
    final double D2 = 123.1234F;
    // 可以直接拿到
    static int i2 = 123;
    // static （静态，可以直接调用，无需通过实例化） 和 final （常量的变量） 是修饰符，不分先后顺序
    static final String s2 = "world";

    public static void main(String[] args) {
        // 通过实例化拿到类的属性
        Demo08 demo08 = new Demo08();
        System.out.println(demo08.s1); // hello
        System.out.println(demo08.i1); // 0
        System.out.println(demo08.D2); // 123.12339782714844
        // 通过static 直接拿到
        System.out.println(i2);
        System.out.println(s2);
    }
}

基本运算符

在这里插入图片描述

package operator;

public class Demo01 {
    public static void main(String[] args) {
        // 加减乘除
        int a = 10;
        int b = 20;
        int c = 31;
        System.out.println(a*b); // 输出200
        System.out.println(a-b); // 输出-10
        System.out.println(a+b); // 输出30
        System.out.println((double)a/b); // 如果不加double，那么就会输出0，因为结果是0.5
        System.out.println(c%a); // 输出1
        // 关系运算符
        System.out.println(a>b); // 输出false
        System.out.println(a<b); // 输出true
        System.out.println(a==b); // 输出false
        System.out.println(a>=b); // 输出false
        System.out.println(a<=b); // 输出true
        System.out.println(a!=b); // 输出true
        // 关于整数的运算，结果验证
        byte a1 = 2;
        short a2 = 33;
        int a3 = 34560;
        long a4 = 123456789L;
        System.out.println(a1+a2+a3+a4); // 输出123491384 类型是long
        System.out.println(a2+a3+a4); // 输出123491382 类型是int
        System.out.println(a3+a4); // 输出123491349 类型是int
        System.out.println((double)a1+a4); // 输出1.23456791E8 类型是double
    }
}

自增运算符和自减运算符

package operator;

public class Demo02 {
    public static void main(String[] args) {
        // 自增运算符 ++ ，自减运算符 --
        int a = 1;
        int b = a++;
        int c = ++a;
        System.out.println(a); // 输出3，因为调用了两次自增
        System.out.println(b); // 输出1，因为提前把a赋值了，然后a才自增
        System.out.println(c); // 输出3，因为把a自增了，才赋值给c
        // 关于幂运算
        double d = Math.pow(2,3);
        System.out.println(d); // 输出8.0
    }
}

逻辑运算符和位运算符

package operator;

public class Demo03 {
    public static void main(String[] args) {
        // &&    ||   !
        boolean a = true;
        boolean b = false;
        System.out.println(a&&b); // 输出false
        System.out.println(a||b); // 输出true
        System.out.println(!(a&&b)); // 输出true
        // 短路运算
        int c = 5;
        int d = 10;
        int f = 20;
        boolean g = (d<f) && (++c>5);
        boolean h = (d<f) && (c++>5);
        boolean k = (d>f) && (c++>5);
        System.out.println(g); // 输出true，因为++c先进行自增，再进行比较
        System.out.println(h); // 输出false，因为++c先进行比较，再进行自增
        System.out.println(k); // 输出false，因为d>f为false，所以后面的语句没有执行
        System.out.println(c); // 输出7

        // 位运算符 & | ~ ^ ，主要是进行位的比较
        /*
        A = 0011 1100
        B = 0000 1101
        --------------------------------
        A&B = 0000 1100 两个必须为1
        A|B = 0011 1101 其中一个为1
        A^B = 0011 0001 都为0，或，都为1，输出0，其中一个为1，则输出1
        ~A = 1100 0011 取反
        ~B = 1111 0010 取反
         */

        // 左移 << 右移 >>
        /*
        0000 0000 0
        0000 0001 1
        0000 0010 2
        0000 0011 3
        0000 0100 4
        0000 1000 8
        0001 0000 16

        2<<3  相当于2像左移动3位，结果等于16
        16<<3 相当于16像右移动3位，结果等于2
         */
        System.out.println(2<<3); // 输出16
        System.out.println(16>>3); // 输出2
    }
}

三元运算符和扩展运算符

public class Demo04 {
    public static void main(String[] args) {
        // 扩展运算符 += -= /= *=
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
        System.out.println(a+=b); // 输出3 a = a + b
        System.out.println(c-=b); // 输出1 c = c - b
        System.out.println(b*=d); // 输出8 b = b * d
        System.out.println(b/=d); // 输出2 b = b / d
        // 字符串连接符 +
        System.out.println("" + a + b); // 输出32 先转为string，然后就是变成拼接
        System.out.println(a + b + ""); // 输出5 先进行加法运算，再变成string

        // 三元运算符
        int score = 50;
        String type = score > 30 ? "大于了" : "小于了";
        System.out.println(type); // 输出大于了
    }
}

包机制

以公司域名，倒着写，作为规范，比如：www.baidu.com，包名就是com.baidu.com

在这里插入图片描述
如果创建包的时候，不会自动分层，把这个选项取消掉即可

在这里插入图片描述

如果是在包里面，都必须引用包名
在这里插入图片描述
这种其实也是包，import导入包，import必须写在package下面

导入包下面全部的类

在这里插入图片描述
导入包下面，某个类

在这里插入图片描述

生成java doc

命令行生成

javadoc -encoding UTF-8 -charset UTF-8 demo01.java

通过idea

在这里插入图片描述

生成之后

在这里插入图片描述

更新日志

提示：将会持续优化更新

smobee

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录