跳至主要內容

Java基础语法

大连赵哥JavaSE基本数据类型运算符流程控制语句数组方法思想约 3888 字大约 13 分钟

哔哩哔哩Java视频课程

(1)基本数据类型

1. 整数类型

package model1.unit1;

public class Java01 {

    public static void main(String[] args) {

        // byte(8)、short(16)、int(32)、long(64)
        // 相同点都可以存储整数。不同点是存储范围由小到大。

        // byte字节(-128)(127)
        byte a = 1;
        System.out.println(a);
        System.out.println(Byte.MIN_VALUE);
        System.out.println(Byte.MAX_VALUE);

        // short短整型(-32768)(32767)
        short b = 2;
        System.out.println(b);
        System.out.println(Short.MIN_VALUE);
        System.out.println(Short.MAX_VALUE);

        // int整型(默认的整数类型)(-2147483648)(2147483647)
        int c = 2147483647;
        System.out.println(c);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);

        // long长整型(-9223372036854775808)(9223372036854775807)
        long d = 4;
        System.out.println(d);
        System.out.println(Long.MIN_VALUE);
        System.out.println(Long.MAX_VALUE);

    }

}

2. 浮点数类型

package model1.unit1;

public class Java02 {

    public static void main(String[] args) {

        // float(32)、double(64)
        // 相同点都可以存储小数、不同点存储范围由小到大。

        // float单精度浮点数(1.4E-45)(3.4028235E38)
        // 用float存储小数的时候必须以F或f结尾
        float a = 1.23F;
        System.out.println(a);
        System.out.println(Float.MIN_VALUE);
        System.out.println(Float.MAX_VALUE);

        // double双精度浮点数(默认的浮点数类型)(4.9E-324)(1.7976931348623157E308)
        double b = 1.2345;
        System.out.println(b);
        System.out.println(Double.MIN_VALUE);
        System.out.println(Double.MAX_VALUE);

    }
}

3. 字符类型和布尔类型

package model1.unit1;

public class Java03 {

    public static void main(String[] args) {

        // char单字字符
        // 注意：单引号
        // 注意：只能存储一个字符
        char a = '你';
        System.out.println(a);

        // boolean布尔类型
        // 布尔类型的数据只有2个true/false
        // true：真、正确、成功
        // false：假、错误、失败
        boolean b = false;
        System.out.println(b);

    }
}

4. 变量

package model1.unit1;

public class Java04 {

    public static void main(String[] args) {

        // 数据类型 变量 = 数据
        // 变量可以存储什么数据取决于它前边的数据类型。
        // 可以把变量理解为一个容器、容器中存储的数据。
// 容器中的数据是可以被修改的。变化的量。

        int a = 3;
        System.out.println(a);
        a = 4;
        System.out.println(a);
        a = 5;
        System.out.println(a);
        a = 6;
        System.out.println(a);

    }
}

5. 常量

package model1.unit1;

public class Java06 {
    public static void main(String[] args) {

        // 被final关键字修饰叫做常量。常量的值是不能被修改的！
        final int b = 9;
        b = 1;

    }
}

6. 类型转换：同类型

package model1.unit1;

public class Java07 {

    public static void main(String[] args) {

        // 相同数据类型之间的类型转换
        // 低精度转换为高精度没问题、高精度转换为低精度需要强制类型转换

        int a = 2;
        long b = 3;
        // b = a;
        a = (int)b;

        float c = 3.0F;
        double d = 6.0;
        d = c;
        c = (float) d;

    }
}

7. 类型转换：不同类型

package model1.unit1;

public class Java08 {

    public static void main(String[] args) {

        // 整数类型和浮点数类型之间的类型转换
        // 整数类型转换为浮点类型没问题、浮点型转换为整型必须强制类型转换

        long a = 3;
        float b = 5.5F;
        b = a;

        a = (long)b;
        System.out.println(a);

    }
}

8. 类型转换：自动

package model1.unit1;

public class Java09 {

    public static void main(String[] args) {

        // 自动类型转换
        // 不同数据类型运算、Java自动把所有低精度的转换为最高精度再进行运算

        int a = 2;// double 2.0
        long b = 3;// double 3.0
        double c = 5;// double 5.0

        double d = a + b + c;
        System.out.println(d);

        System.out.println(3 / 2.0);

    }
}

9. 类型转换：整数和字符

package model1.unit1;

public class Java10 {

    public static void main(String[] args) {

        // int(32)和char(16)之间的类型转换
        // 编码了解：UTF-8、GBK、GB2312、ISO8859-1等
        // char->int：字符对应的编码
        // int->char：编码对应的字符

        char c = 'A';
        int i = c;
        System.out.println(i);

        int x = 65;
        char y = (char)x;
        System.out.println(y);

    }
}

10. 大数类：BigInteger

package model1.unit1;

import java.math.BigInteger;

public class Java13 {

    public static void main(String[] args) {

        // 整数存储范围超出long

        long a = 9223372036854775807L;
        System.out.println(a);
        System.out.println(Long.MAX_VALUE);

        BigInteger b = new BigInteger("922337203685477580781234");
        System.out.println(b);

    }
}

11. 大数类：BigDecimal

package model1.unit1;

import java.math.BigDecimal;

public class Java11 {

    public static void main(String[] args) {

        // 浮点计算可能出现误差
        double a = 1.0;
        double b = 0.9;
        System.out.println(a - b);

        BigDecimal x = new BigDecimal("1.0");
        BigDecimal y = new BigDecimal("0.9");
        System.out.println(x.subtract(y));

    }
}

12. 大数类：BigDecimal

package model1.unit1;

import java.math.BigDecimal;

public class Java12 {

    public static void main(String[] args) {

        // 超出double存储范围

        double a = 1.7976931348623157E308;
        System.out.println(Double.MAX_VALUE);

        BigDecimal b = new BigDecimal("1.7976931348623157E30891234");
        System.out.println(b);

    }
}

13. 数字下划线

package unit1;

public class Java10 {

    public static void main(String[] args) {

        // 数值字面量
        // 整数或浮点数都允许在数字之间插入任意多个下划线、不会对数值产生影响
        int a = 1_000_000;
        System.out.println(a);
        double b = 123_456_789.5_5_5;
        System.out.println(b);

    }
}

(2)运算符

1. 算数运算符

package model1.unit2;

public class Java01 {

    public static void main(String[] args) {

        System.out.println(3 + 2);
        System.out.println(3 - 2);
        System.out.println(3 * 2);
        System.out.println(3 / 2);// 除
        System.out.println(3 % 2);// 余数

    }
}

2. 比较运算符

package model1.unit2;

public class Java02 {

public static void main(String[] args) {

        // 运算结果都是布尔值true/false

        System.out.println(3 > 2);
        System.out.println(3 >= 2);
        System.out.println(3 < 2);
        System.out.println(3 <= 2);
        System.out.println(3 == 2);// 相等
        System.out.println(3 != 2);// 不相等

    }
}

3. 逻辑运算符

package model1.unit2;

public class Java03 {

    public static void main(String[] args) {

        // &&逻辑与：表示并且的意思、要求两边条件同时满足。
        System.out.println(true && false);
        System.out.println(false && true);
        System.out.println(true && true);// true
        System.out.println(false && false);

        // ||逻辑或：表示或者的意思、要求满足一个条件即可。
        System.out.println(true || false);
        System.out.println(false || true);
        System.out.println(true || true);
        System.out.println(false || false);// false

        // !逻辑非：表示取反的意思。
        System.out.println(!true);
        System.out.println(!false);

    }
}

4. 赋值运算符

package model1.unit2;

public class Java04 {
    public static void main(String[] args) {

        int a = 3;
        System.out.println(a);
        //a = a + 2;
        a += 2;
        System.out.println(a);
        a -= 2;
        System.out.println(a);
        a *= 2;
        System.out.println(a);
        a /= 2;
        System.out.println(a);
        a %= 2;
        System.out.println(a);

// 赋值运算符优点：简洁、自动类型转换
        int c = 2;
        double d = 5.5;
        c += d;
        System.out.println(c);

    }
}

5. 自增自减运算符

package model1.unit2;

public class Java06 {

public static void main(String[] args) {

        // ++自增1、--自减1

        int a = 2;
        System.out.println(a);
        // a = a + 1;
        // a += 1;
        a++;
        System.out.println(a);
        a--;
        System.out.println(a);

        // ++放在运算表达式的前边：先自增、再参与运算
        // ++放在运算表达式的后边：先参与运算、再自增
        int b = 2;
        int c = b++;
        System.out.println(c);

    }
}

6. 三目运算符

package model1.unit2;

public class Java08 {

    public static void main(String[] args) {

        // (true/false) ? (true的结果A) : (false的结果B)

//        int a = (false ? 2 : 3);
//        System.out.println(a);

        int a = 2;
        int b = 3;
        int c = (a > b) ? a : b;
        System.out.println(c);

        int x = Math.max(5, 6);
        System.out.println(x);

    }
}

(3)流程控制语句

1. if分支语句

package model1.unit3;

public class Java01 {

public static void main(String[] args) {

        // 流程控制语句
        // 分支语句：if分支、switch分支
        // 循环语句：for循环、while循环、do while循环

        // (1)if分支语句
        // 根据布尔值true/false来执行不同的分支的语句块

        // 单分支的if语句(有可能不执行)
        if (true) {
            System.out.println(10);
        }
        if (false) {
            System.out.println(20);
        }

        // 两分支的if语句(至少执行其中一个分支)
        if (false) {
            System.out.println(30);
        } else {
            System.out.println(40);
        }

        // 多分支的if语句(只执行其中一个分支)
        if (false) {
            System.out.println(50);
        } else if (false) {
            System.out.println(60);
        } else {
            System.out.println(70);
        }

    }
}

2. switch分支语句

package model1.unit3;

public class Java02 {

public static void main(String[] args) {

        // (2)switch分支语句
        // 根据具体数值(byte、short、int、char)来执行不同的分支
        // break关键字表示跳出switch语句

        int a = 35;
        switch (a) {
            case 1:{
                System.out.println(1);
                break;
            }
            case 2:{
                System.out.println(2);
                break;
            }
            case 3:{
                System.out.println(3);
                break;
            }
            default:{
                System.out.println(100);
            }
        }

    }
}

3. for循环语句

package model1.unit3;

public class Java03 {

public static void main(String[] args) {

        // (3)for循环语句

        // 执行流程
        // A-B(t)-D-C-B(t)-D-C-B(f)-退出
        // for (A;B;C) { D }

        // 1...10
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }

        // 10...1
        for (int i = 10; i > 0; i--) {
            System.out.println(i);
        }

    }
}

4. while循环

package model1.unit3;

public class Java04 {

    public static void main(String[] args) {

        // (4)while循环

        // A(t)-B-A(t)-B-A(f)-退出
        // while (A) { B }

        int i = 1;
        while (i < 10) {
            System.out.println(i);
            i++;
        }

    }
}

5. do while循环

package model1.unit3;

public class Java05 {

    public static void main(String[] args) {

        // (5)do while循环

        // while循环先判断再执行
        // do while循环先执行再判断。至少执行一次。

        // 1...10
        int i = 1;
        do {
            System.out.println(i);
            i++;
        } while (i <= 10);

    }
}

6. continue和break

package model1.unit3;

public class Java06 {

    public static void main(String[] args) {

        // continue关键字：终止循环中的一次直接执行下一次。
        // break关键字：终止整个循环结束循环。注意只能退出当前一个循环。
        // return关键字：return;表示代码返回终止。可以退出多重循环嵌套。

        while (true) {
            for (int i = 1; i < 11; i++) {
                if (i == 3) {
                    // continue;
                    // break;
                    return;
                }
                System.out.println(i);
            }
        }

    }
}

7. continue/break/return区别

package unit1;

public class Java01 {

    public static void main(String[] args) {

        // continue、break、return3个关键字

        // continue：用于循环表示终止当前这一次循环直接执行下一次

        // break：用于循环表示跳出当前整个循环
        // 注意：在循环嵌套中只能跳出一层循环。还可用于switch语句跳出分支语句

        // return：用于没有返回值的方法表示代码结束执行、可以跳出多层循环

        // return：用于有返回值的方法表示返回结果、把结果返回到方法的调用处

        while (true) {
            for (int i = 1; i <= 10; i++) {
                if (i == 3) {
                    // continue;
                    // break;
                    return;
                }
                System.out.println(i);
            }
        }

//        int max = m(2, 3);
//        System.out.println(max);

    }

    private static int m(int a, int b) {
        return a > b ? a : b;
    }

}

(4)数组

1. 创建数组

package model1.unit4;

public class Java01 {

    public static void main(String[] args) {

        // (1)创建数组

        // []表示数组类型
        // 数组的长度一旦创建就不能更改！

        // 方式一：
        int[] a = {5, 3, 2, 6};

        // 方式二：
        // new关键字：表示创建一个新的数组。
        // [4]：表示这个数组的长度是4、数组中存储元素的个数
        // 默认值：整数0、浮点数0.0、布尔false
        int[] b = new int[4];

    }
}

2. 元素的存取

package model1.unit4;

public class Java02 {

public static void main(String[] args) {

        // 数组中每个元素都有一个对应的下标、元素的存取都必须通过下标实现。
        // 元素的下标是从零开始计数的。注意区分元素和下标！

        int[] a = {5, 2, 8, 6};
        // 0  1  2  3

        int c = a[0];
        a[0] = a[3];
        a[3] = c;

        System.out.println(a[0]);
        System.out.println(a[3]);

//        int b = a[2];
//        System.out.println(b);
//        a[2] = 9;
//        System.out.println(a[2]);

    }
}

3. 数组的遍历

package model1.unit4;

public class Java03 {

    public static void main(String[] args) {

        // (3)数组的遍历

        int[] a = {1, 2, 3, 4, 5};

        // 方式一：
        // 数组长度的属性：数组.length
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }

        // 方式二：
        for (int b : a) {
            System.out.println(b);
        }

    }
}

(5)方法

1. 没有返回值的方法

package model1.unit5;

public class Java01 {

    public static void m1() {
        System.out.println(1);
    }

    public static void m2(int a, double b, char c){
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }

    // 打印2个整数中的最大值
    public static void m3(int a, int b) {
        if (a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }

    public static void main(String[] args) {

        // 方法的分类：2种
        // 没有返回值的方法：只需要实现功能即可。
        // 有返回值的方法：不但需要实现功能、还必须有一个返回结果。

        // (1)没有返回值的方法

        // 定义：
        // public static void 方法名字(参数列表) { 方法实现 }

        // 调用：
        // 方法名字(参数列表);
        // 注意：参数的个数、类型、顺序完全一致。

        m1();
        m2(2, 3.5, '你');
        m3(5, 9);

        int[] x = {};
        char y = ' ';
        m4(x, y);

    }

    public static void m4(int[] x, char y){

    }

}

2. 有返回值的方法

package model1.unit5;

public class Java02 {

    public static int m1() {
        return 100;
    }

    public static boolean m2(float a, double b) {
        System.out.println(a);
        System.out.println(b);
        if (a < 10) {
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) {

        // 有返回值的方法

        // 定义：
        // public static 返回类型 方法名字(参数列表) { 方法的实现  return 返回结果;}
        // return关键字：返回的意思、把结果返回到方法的调用处。

        // 调用：
        // 返回类型  变量  =  方法名字(参数列表);

        int a = m1();
        System.out.println(a);
        boolean b = m2(3.4F, 6.7);
        System.out.println(b);

        int max = m3(7, 3);
        System.out.println(max);

    }

    // 返回2个变量中的最大值
    public static int m3(int a, int b){
        return (a > b) ? a : b;
    }

}

3. 方法角色

package model1.unit5;

public class Java03 {

    // 自定义方法的角色：实现方法实现功能的人
    public static int m1(int c, int d) {
       if (c > d) {
           System.out.println(c);
            return c;
       }
        System.out.println(d);
       return d;
    }

    // 有返回值的方法：必须有返回值！
    public static int m2(){
        // 第一步：定义存储结果的变量
        int result = 0;
        // 第二步：把结果存储到变量中

        // 第三步：返回存储结果的变量
        return result;
    }

    public static void main(String[] args) {

        // 在主方法中编写代码的角色：用户、使用方法调用方法的人
        // 找出2个变量中的最大值?
        int a = 2;
        int b = 4;
        int c = m1(a, b);
        System.out.println(c);

    }

}

4. 可变参数

package unit2;

import java.util.Arrays;

public class Java19 {

    // 可变参数的本质是数组int[]
    static void m1(int...arr) {
        for (int a: arr) {
            System.out.println(a);
        }
    }

    // 可变参数的本质是数组int[]
    static void m2(int a, char c, String...arr) {
        for (String s: arr) {
            System.out.println(s);
        }
    }

    public static void main(String[] args) {

        // 可变参数：数据类型...参数名
        // 如果可变参数和其它参数一起使用、可变参数只能作为方法的最后一个参数
        // 方法名(参数列表)
        // 参数注意事项：参数个数、参数类型、参数顺序都要完全一致。
        // 问题：需求中参数个数不固定、可变参数解决

        m1(1,2,3,4,5,6);
        m2(100, '你', "1","abc","xyz");

    }
}

5. 方法的分类

package model2.unit2;

public class Java10 {
    public static void main(String[] args) {

        // 方法总结归纳：方法的分类
        // 方法是否有返回结果：没有返回值的方法(void)、有返回值的方法(返回类型)
        // 方法是否有参数：无参、有参
        // 方法是否静态：静态方法(类的方法)、非静态方法(对象的方法)
        // 方法是否实现：抽象方法、实现方法
        // 方法的可见性：private、默认、protected、public

    }
}

(6)编程思想

1. 循环嵌套

package model1.unit6;

public class Java01 {

    public static void main(String[] args) {

        // 分步骤拆分思想：把一个复杂问题拆分成多个步骤一个一个去解决。

        // 打印数字矩阵
        // 1
        // 121
        // 12321
        // 1234321
        // 123454321

        // (1)输出第1行到第5行
        for (int i = 1; i <= 5; i++) {

            // (2)打印第i行的数字、递增
            for (int j = 1; j <= i; j++) {
                System.out.print(j);
            }

            // (3)打印第i行的数字、递减
            for (int j = (i-1); j >= 1 ; j--) {
                System.out.print(j);
            }

            // (4)换行
            System.out.println();

        }

    }
}

2. 多维数组

package model1.unit6;

public class Java02 {

    public static void main(String[] args) {

        // 用一维数组的思想来理解多维数组

        // 二维数组
        int[][] a = {{1,2}, {3,4,5}};

        for (int[] x:a) {
            // 遍历x数组
            for (int y:x) {
                System.out.println(y);
            }
        }

        //System.out.println(a[1][0]);// 分为2步实现

        // 三维数组
        int[][][] b = { {{1,2}}, {{3},{4}} };

        for (int[][] t:b) {
            // 数组t
            for (int[] f:t) {
                // 数组f
                for (int k:f) {
                    System.out.println(k);
                }
            }
        }

        //System.out.println(b[1][0][0]);// 分为3步实现

    }
}

3. 测试驱动开发

package model1.unit6;

public class Java03 {

    public static void main(String[] args) {

        // 开发角色和测试角色灵活转换
        // 如果没有思路、难点考虑很久
// 可以从一个功能的实现者身份转换为一个需求者的身份

        int[] arr = {4,5,6,7,8,9};
        // (1)求数组中元素的偶数和
        // (2)求数组中质数和(只能被1和它本身整除的数)
        int x = 0;
        for (int a:arr) {
            // 提需求：需要一个方法、判断是否是质数、如果是返回true、不是返回false
            if (m(a)) {
                x += a;
            }
        }
        System.out.println(x);

    }

    // 需要一个方法、判断是否是质数、如果是返回true、不是返回false
    // 判断b是否是质数
    public static boolean m(int b) {
        for (int i = 2; i < b; i++) {
            if (b % i == 0) {
                return false;
            }
        }
        return true;
    }

}

4. 方法复用

package model1.unit6;

public class Java04 {

    public static void main(String[] args) {

        // 方法的复用：方法的重复使用、重复调用
        // 返回2个数中的最大值
        int a = 2;
        int b = 3;
        int x = 5;
        int c = m(m(a, b), x);
        System.out.println(c);

    }
    private static int m(int a, int b) {
        return a > b ? a : b;
    }

}