Java基础篇一_基础小结

最新推荐文章于 2023-12-15 08:32:11 发布

柯柯不会Java

最新推荐文章于 2023-12-15 08:32:11 发布

阅读量122

点赞数 1

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

本文链接：https://blog.csdn.net/qq_46601365/article/details/115363033

版权

java 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

Java基础

Java初生

Java 2标准版J2SE：去占领桌面

Java 2移动版J2ME：去占领手机

Java 2企业版J2EE：去占领服务器（只有这个成功了）

三高概念

高性能、高可用、高并发

Java特性和优势

简单性

面向对象

可移植性：Write Once、Run Anywhere

高性能

分布式

动态性

多线程

安全性

健壮性

Java三大版本

JavaSE：标准版（卓面程序、控制台开发…）

~~JavaME~~：嵌入式开发（手机，小家电…）

JavaEE：E企业开发（web端、服务器开发）

JDK、JRE、JVM

JDK：Java Development Kit（Java开发者工具，包括JRE和JVM）

JRE：Java Runtime Environment（Java运行时环境，包括JVM，即安装JRE就可以运行Java程序）

JVM：Java Virtual Machine (Java虚拟机，相当于在所有的操作系统上模拟一个小的CPU处理Java相关的东西，实现跨平台)

Java程序运行机制

编译型语言：通过编译器将写的代码转换为计算机可以执行的代码，例如：C语言、C++

解释型语言：直接将代码一步一步解释给计算机，使其能够执行，例如：python

Java：属于编译型和解释型语言，*.java 文件先通过Java编译器变成 *.class文件（预编译，即生成机器码和Java程序之间class文件），运行时再通过类加载器加载进JVM、之后会通过字节码校验器校验代码的正确性，最后通过解释器，走一步运行一步解释给操作系统

Java数据类型

Java的数据类型分为两大类

注意：Java属于强类型语言，即要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

基本类型：变量名指向具体的数值

引用类型：变量名指向存数据对象的内存地址,即变量名指向hash值

package base;

/**
 * @ClassName: base.Demo01
 * @Description:
 * @Author: keke
 * @Date: 2021/3/29
 */
public class Demo01 {

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

        //整数
        int num1 = 10; //最常用
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L; //Long类型要在数字后面加个L

        //小数：浮点数
        float num5 = 50.1F; //Float类型要在数字后面加个F
        double num6 = 3.1415926;

        //字符
        char name = '过';
        //字符串，String不是关键字，是类
        String namea = "柯柯";

        //布尔值：是非
        boolean flag = true;
//        boolean flag = false;

    }

}

扩展

package base;

/**
 * @ClassName: base.Demo02
 * @Description:
 * @Author: keke
 * @Date: 2021/3/29
 */
public class Demo02 {
    public static void main(String[] args) {
        //整数扩展： 进制     二进制0b      十进制      八进制0      十六进制0x
        int i = 10;
        int i2 = 010; //八进制0
        int i3 = 0x10; //十六进制0x  0~9 A~F

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);

        System.out.println("========================================");

        //浮点数扩展： 例：银行业务怎么表示？ 使用BigDecimal数学工具类
        //float      有限  离散  舍入误差  大约  接近但不等于
        //double
        //最好完全避免使用浮点数进行比较  *
        float f = 0.1f; //0.1
        double d = 1.0/10; //0.1
        System.out.println(f==d); //false

        float d1 = 231231212121f;
        float d2 = d1 + 1;
        System.out.println(d1==d2); //true

        System.out.println("========================================");

        //字符扩展
        char c1 = 'a';
        char c2 = '中';

        System.out.println(c1);
        System.out.println((int)c1); //强制转换
        System.out.println(c2);
        System.out.println((int)c2); //强制转换

        System.out.println("========================================");

        //所有的字符本质还是数字
        //编码 Unicode（本质是张表，其中97=a 65=A）：可以用于处理各种语言的文字，占2个字节，最多可以表示65536个字符

        //一般可以通过Unicode编码转义表示一些字符，范围：U0000-UFFFF
        char c3 = '\u0061';
        System.out.println(c3); //a

        System.out.println("========================================");

        //转义字符
        //例：\t 制表符（相当于一个tab键）
        //   \n 换行
        System.out.println("Hello\tWorld");
        System.out.println("Hello\nWorld");

        System.out.println("========================================");

        /**
         * 需要注意：1.栈区存引用和基本类型，不能存对象，而堆区存对象
         *          2.==是比较地址，equals()比较对象内容
         * String str1 = "abcd"的实现过程：
         * 首先栈区创建str1引用，然后在String池（存在堆内存中，开辟独立的内存空间）中寻找其指向的内容为"abcd"的对象，如果String池中没有，
         * 则创建一个，然后str1指向String池中的对象，如果有，则直接将str1指向"abcd""；如果后来又定义了字符串变量 str2 = "abcd",则直接
         * 将str2引用指向String池中已经存在的“abcd”，不再重新创建对象；当str1进行了赋值（str1=“abc”），则str1将不再指向"abcd"，而是
         * 重新指String池中的"abc"，此时如果定义String str3 = "abc",进行str1 == str3操作，返回值为true，因为他们的值一样，地址一样，
         * 但是如果内容为"abc"的str1进行了字符串的+连接str1 = str1+"d"；此时str1指向的是在堆中新建的内容为"abcd"的对象，即此时进行
         * str1==str2，返回值false，因为地址不一样。
         * String str3 = new String("abcd")的实现过程：
         * 直接在堆中创建对象。如果后来又有String str4 = new String("abcd")，str4不会指向之前的对象，而是重新创建一个对象并指向它，
         * 所以如果此时进行str3==str4返回值是false，因为两个对象的地址不一样，如果是str3.equals(str4)，返回true,因为内容相同
         **/
        String str1 = "abcd";
        String str2 = "abcd";
        System.out.println(str1 == str2); //true
        System.out.println(str1.equals(str2)); //true

        String str3 = new String("abcd"); //调用String的有参构造方法：复制原来的串的char数组和哈希值到新的对象
        String str4 = new String("abcd");
        System.out.println(str3 == str4); //false
        System.out.println(str3.equals(str4)); //true

        //布尔值扩展
        boolean flag = true;
        if (flag == true) {} //新手
        if (flag) {} //老手
        //less is more! 代码要精简易读

    }
}

科普：什么是字节

位(bit)：是计算机内部数据存储的最小单位，11001100是一个八位二进制数

字节(byte)：是计算机中数据处理的基本单位，习惯上用大写B表示

1B(byte,字节) = 8bit(位)

字符：是指计算机中使用的字母、数字、字和符号

1bit表示1位

1Byte表示一个字节 1B= 8b

1024B=1KB

1024KB=1M

1024M=1G

https://blog.csdn.net/qq_31615049/article/details/80574551

思考：电脑的32位和64位有什么区别

32位和64位表示什么意思？

1、32位和64位意思是处理器一次能处理的最大位数；

2、32位系统的最大寻址空间是2的32次方=4294967296(bit)= 4(GB)左右；

3、64位系统的最大寻址空间为2的64次方=4294967296(bit)的32次方，数值大于1亿GB。

32位和64位有什么区别呢？

1、CPU要求不同。CPU有32位和64位之分，32位的CPU只能安装32位系统，而64位的CPU既可以安装32位系统也可以安装64位系统。

2、运算速度不同。64位CPU的指令集可以运行64位数据指令，比32位CPU提高了一倍。

3、寻址能力不同。32位系统的处理器最大只支持到4G内存，而64位系统最大支持的内存高达亿位数，实际运用过程中大多数的电脑32位系统最多识别3.5GB内存，64位系统最多识别128GB内存。

4、软件兼容性不同。64位系统比32位系统的软件少，主要是64位系统推出的时间不长，所以64位系统的兼容性不如32位，虽然可以兼容32位软件，但是部分32位的软件在64位系统无法运行，但是目前的Win7 64位系统兼容性好了很多。

Java的类型转换

由于Java是强类型语言，所以要进行有些运算的时候，需要类型转换

低---------------------------------------------------------------------高

byte、short、char —> int —> long —> float —> double

运算中不同类型的数据先转换为同一类型再进行运算

强制类型转换

自动类型转换

package base;

/**
 * @ClassName: base.Demo03
 * @Description:
 * @Author: keke
 * @Date: 2021/3/30
 */
public class Demo03 {

    public static void main(String[] args) {
        //强制转换  (类型)变量名  高-->低
        int i = 128;
        byte b = (byte) i; //-128 内存溢出

        //自动转换  低-->高
        int i2 = 129;
        double c = i2; //129.0

        System.out.println(i);
        System.out.println(b);

        System.out.println(i2);
        System.out.println(c);

        /*
        * 注意：
        * 1.不能对布尔值进行转换
        * 2.不能把对象类型转换为不相干的类型
        * 3.在把高容量转换到低容量时，强制转换
        * 4.在强制转换的时候可能存在内存溢出，或者精度丢失的问题！
        * */

        System.out.println("===============================");

        System.out.println((int)23.7); //23 精度丢失
        System.out.println((int)-45.89f); //45 精度丢失

        System.out.println("===============================");

        char d = 'a';
        int e = d + 1; //自动转换
        System.out.println(e); //98
        System.out.println((char)e); //b 强制转换
    }

}

package base;

/**
 * @ClassName: base.Demo04
 * @Description:
 * @Author: keke
 * @Date: 2021/3/30
 */
public class Demo04 {
    public static void main(String[] args) {
        //操作较大数时，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money * years;
        System.out.println(total); //-1474836480 计算的时候溢出了
        long total2 = money * years;
        System.out.println(total2); //-1474836480 无法解决溢出问题，因为是先计算得到的是int类型再转换为long类型

        long total3 = money * ((long)years); //这里的(long)years属于自动转换，有时候自动转换也需要手动
        System.out.println(total3); //成功解决 先把一个数转换为long，再计算
    }
}

Java变量和常量

Java是一种强类型语言，每个变量都必须声明其类型

Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

作用域：

局部变量：作用在它定义的方法或者方法里面的程序块变量。只能作用在方法里面或者方法里面的程序块里面。局部变量必须初始化，否则使用时编译会出错。
全局变量：分为实例变量和类变量。区别在于类变量使用static关键字修饰，作用域是类范围的，所有该类的实例都可以共同使用这个变量，实例变量作用在实例层次，为实例独有，互不干扰。全局变量不要求必须实例化，基本类型和引用类型都会获得默认值，对象类型实例不会编译报错，但是如果直接使用，会出现NullPointerException异常。

/**
 * @ClassName: Demo05
 * @Description:
 * @Author: keke
 * @Date: 2021/3/30
 */
public class Demo05 {

    //属性：变量

    //实例变量：从属于对象，必须声明可不初始化
    //若不初始化，数值类型默认为0或者0.0，字符默认u0000，但输出还是0
    //布尔类型默认为false
    //除了基本类型，其他的默认值都是null
    String name;
    int age;

    //类变量 static 必须声明可不初始化
    static double salary = 2500;

    //main方法
    public static void main(String[] args) {
        //局部变量；必须声明和初始化值，生命周期为本方法内部
        int i = 10;
        System.out.println(i);

        Demo05 demo05 = new Demo05();
        System.out.println(demo05.age); //0
        System.out.println(demo05.name); //null

        System.out.println(salary); //直接调用，不用new
    }

    //其他方法
    public void add() {
//        System.out.println(i);
    }

}

常量：初始化后不能再改变值，不会变动的值

定义：final 常量名=值;

常量名一般使用大写字符

/**
 * @ClassName: Demo06
 * @Description:
 * @Author: keke
 * @Date: 2021/3/30
 */
public class Demo06 {

    //static、final修饰符，不存在先后顺序
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }

}

Java运算符

1.算术运算符(单目)：+ 、-、*、/、%(模，即取余)、++(自增)、–(自减)

2.赋值运算符：=

3.关系运算符：>、<、>=、<=、==、!=、instanceof

4.逻辑运算符：&&、||、!

5.位运算符：&、|、^、~、>>、<<、>>>

6.条件运算符(三目)：?、:

7.扩展赋值运算符：+=、-=、*=、/=

优先级：括号级别最高，逗号级别最低，单目 > 算术 > 位移 > 关系 > 逻辑 > 三目 > 赋值，但是注意在Java中，一般用()来区别先后运算，提高代码可读性

package com.keke.operator;

/**
 * @ClassName: Demo01
 * @Description:
 * @Author: keke
 * @Date: 2021/3/30
 */
public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;

        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/b); //0
        System.out.println(a/(double)b); //0.5 两int类型的运算如果结果为小数需要提前转化

        System.out.println("=======================");

        long e = 12133294394939493L;
        int f = 123;
        short g = 10;
        byte h = 8;

        float i = 1.25F;
        double j = 1.34;
        char k = 'a';

        //验证结果类型可以将结果强制转换为String，然后看提示
        //运算结果类型，如果有double，结果为double；再如果有float，结果为float；再如果有long，结果为long，其他都是int
        System.out.println(e+f+g+h); //Long
        System.out.println(f+g+h); //int
        System.out.println(g+h); //int

        System.out.println(j+i); //double
        System.out.println(i+h); //float
        System.out.println(k+j); //double
        System.out.println(k+e); //long
        System.out.println(k+g); //int
    }
}

package com.keke.operator;

/**
 * @ClassName: Demo02
 * @Description:
 * @Author: keke
 * @Date: 2021/3/31
 */
public class Demo02 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确、错误   布尔值
        //常与if运算

        int a = 10;
        int b = 20;
        int c = 21;

        //取余/模运算
        System.out.println(c%a); //c / a   21 / 10 = 2...1

        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);

    }
}

package com.keke.operator;

/**
 * @ClassName: Demo03
 * @Description:
 * @Author: keke
 * @Date: 2021/3/31
 */
public class Demo03 {

    public static void main(String[] args) {
        // ++ 自增 -- 自减   一元运算符
        int a = 3;

        int b = a++; //先给b赋值，再自增
        int c = ++a; //先自增，再给c赋值

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //幂运算 2^3=2*2*2=8，Java中可以用Math工具类来实现
        double pow = Math.pow(2, 3);
        System.out.println(pow);

    }

}

package com.keke.operator;

/**
 * @ClassName: Demo04
 * @Description:
 * @Author: keke
 * @Date: 2021/3/31
 */
public class Demo04 {

    public static void main(String[] args) {
        //逻辑运算符
        //与(and) 或(or) 非(取反)
        boolean a = true;
        boolean b = false;

        System.out.println("a&&b:"+(a&&b)); //逻辑与运算：两个变量都为真结果才是真
        System.out.println("a||b:"+(a||b)); //逻辑或运算：两个变量有一个为真结果就是真
        System.out.println("!(a&&b):"+!(a&&b)); //取反运算：如果为真，则为假，如果为假，则为真

        //短路运算
        int c = 5;
        boolean d = (c<4) && (c++<4);
        System.out.println(d);
        System.out.println(c);

    }

}

package com.keke.operator;

/**
 * @ClassName: Demo05
 * @Description:
 * @Author: keke
 * @Date: 2021/3/31
 */
public class Demo05 {

    public static void main(String[] args) {
        /*
        * 位运算：好处是效率极高！！！因为直接是计算机底层运算
        * A = 0011 1100
        * B = 0000 1101
        * A&B = 0000 1100 如果两个都为1，即为1，否则为0
        * A|B = 0011 1101 如果两个都为0，即为0，否则为1
        * A^B = 0011 0001 如果两个相同，即为0，不相同围为1
        * ~B = 1111 0010 取反
        *
        * 常见面试题：计算机2*8怎么运算最快
        * 解答：拆分为2*2*2*2，在位运算里计算机运算非常快
        *
        * << 左移 相当于*2
        * >> 右移 相当于/2
        * 0000 0000    0
        * 0000 0001    1
        * 0000 0010    2
        * 0000 0011    3
        * 0000 0100    4
        * 0000 1000    8
        * 0001 0000    16
        * */

        System.out.println(2<<3); //16
    }

}

package com.keke.operator;

/**
 * @ClassName: Demo06
 * @Description:
 * @Author: keke
 * @Date: 2021/3/31
 */
public class Demo06 {

    public static void main(String[] args) {
        //赋值运算符
        int a = 10;
        int b = 20;

        a += b; //a = a + b
        System.out.println(a);
        a -= b; //a = a - b
        System.out.println(a);

        System.out.println("===========================");

        //字符串连接符 + ，只要有一个是String，就会把后面的都转换为字符串再相加
        System.out.println(""+a+b);
        System.out.println(a+b+"");

    }

}

package com.keke.operator;

/**
 * @ClassName: Demo07
 * @Description:
 * @Author: keke
 * @Date: 2021/3/31
 */
public class Demo07 {

    public static void main(String[] args) {
        // 三元运算符
        // x ? y : z
        //如果x==true，则结果为y，否则结果为z

        int score = 50;
        String type = score > 60 ? "及格": "不及格";
        System.out.println(type);

        //instanceof运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型），结果返回一个布尔值
        String name = "张三";
        boolean flag = name instanceof String;  //name是String类型的，返回true
        System.out.println(flag);
    }

}

阿里Java开发手册：注意要仔细阅读，大有帮助！

柯柯不会Java

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础篇一_基础小结

Java基础Java初生Java 2标准版J2SE：去占领桌面Java 2移动版J2ME：去占领手机Java 2企业版J2EE：去占领服务器（只有这个成功了）三高概念高性能、高可用、高并发Java特性和优势简单性面向对象可移植性：Write Once、Run Anywhere高性能分布式动态性多线程安全性健壮性Java三大版本JavaSE：标准版（卓面程序、控制台开发…）JavaME：嵌入式开发（手机，小家电…）JavaEE：E企业开发（web端、服务器开发）JDK
复制链接

扫一扫