Java入门基础知识

计算机基础

二进制

​ 计算机中的数据不同于人们生活中的数据，人们生活采用十进制数，而计算机中全部采用二进制数表示，它只包含
0、1两个数，逢二进一，1+1=10。每一个0或者每一个1，叫做一个bit（比特）。二进制数系统中，每个0或1就是一个位，叫做bit（比特）。

进制转换

十进制转二进制

使用除以2获取余数的方式

十进制转二进制

转成Java代码

    public static String covertBin(int num) {
        String binStr = "";
//        辗转相除 余数倒序拼接 直到商为1时跳出循环
        while (num != 1) {
            binStr = num % 2 + binStr;
            num /= 2;
        }
        return "1" + binStr;
    }

二进制数据转成十进制数据

使用8421编码的方式 例如

二进制数据1001011转成十进制
1   0   0   1   0   1   1
64  32  16  8   4   2   1

把有1的位上的十进制数求和
64+8+2+1=75
其实也就是1*64+1*8+1*2+1*1=75

字节

计算机中最小储存单元，打开计算机文件属性即可看到是多少字节。8个bit（二进制位） 0000-0000表示为1个字节，写成1 byte或者1 B。

也就是一个大B等于8个小b：

8 bit = 1 B
1024 B =1 KB
1024 KB =1 MB
1024 MB =1 GB
1024 GB = 1 TB

其实大家常见的例如100Mbps宽带，换算成大B除以8，那其实也就12.5MB/s了

JAVA环境

JRE 和 JDK

JRE (Java Runtime Environment) ：是Java程序的运行时环境，包含JVM 和运行时所需要的 核心类库 。
JDK (Java Development Kit)：是Java程序开发工具包，包含 JRE 和开发人员使用的工具。
我们想要运行一个已有的Java程序，那么只需安装 JRE 即可。
我们想要开发一个全新的Java程序，那么必须安装 JDK 。

总结：也就是说jdk中包含jre与开发工具包kit。然后jre中又包含jvm。

配置环境变量

1. 计算机鼠标右键,选择 属性
2. 选择 高级系统设置
3. 高级 选项卡，点击 环境变量
4. 点击 新建 ，创建新的环境变量
5. 变量名输入 JAVA_HOME ，变量值输入JDK9的安装目录 c:\Java9\jdk-9.0.1（这里只是举例 请填写真实路径）
6. 选中 Path 环境变量， 双击 或者 点击编辑
7. 在变量值的最前面，键入 %JAVA_HOME%\bin; 分号必须要写，必须是英文格式
8. 环境变量配置完成，重新开启DOS命令行，在任意目录下输入 javac或java -version 命令，运行成功

基础知识

第一个Java程序

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("极四维博客");
    }
}

记事本编辑如上，输入命令

javac HelloWorld.java //编译
java HelloWorld //运行

编译就是将Java代码转换成计算机能懂的文件，当用javac编译后你会发现实际生成了一个HelloWorld.class的文件。代码错误可能会导致编译失败。

Main方法写法固定格式不变，JVM在运行的时候，都会从main方法这里开始执行。

运行将jvm运行编译好的程序

关键字keywords

HelloWorld案例中，出现的关键字有 public 、 class 、 static 、 void 等，这些单词已经被Java定义好，全部都是小写字母，变量进来别与关键字同名。

标识符

是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。
HelloWorld案例中，出现的标识符有类名字 HelloWorld 。

命名规则： 硬性要求
标识符可以包含 英文字母26个(区分大小写) 、 0-9数字 、 $（美元符号） 和 _（下划线） 。标识符不能以数字开头。标识符不能是关键字。
命名规范： 软性建议
类名规范：首字母大写，后面每个单词首字母大写（大驼峰式），例如HelloWorld。
方法名规范： 首字母小写，后面每个单词首字母大写（小驼峰式），例如helloWorld。
变量名规范：全部小写。

虽然不遵守上述规范可以编译程序，但这些也都形成一种规范了，更详细请参见阿里巴巴Java开发规范

注释

单行注释以 //开头 换行结束
多行注释以 /* 开头 以 */ 结束

数据类型

基本数据类型：包括 整数 、 浮点数 、 字符 、 布尔 。
引用数据类型：包括 类 、 数组 、 接口 。

类型	字节长度	取值范围
int	4字节	-2 147 483 648 ~ 2 147 483 647（即-231 ~ 231-1）
short	2字节	-32 768 ~ 32 767
long	8字节	-9 223 372 036 854 775 808 ~ 9 223 372 036 854 775 807（即-263 ~ 263-1）
byte	1字节	-128 ~ 127
float	4字节	大约±3.402 823 47E+38F(6~7位有效数字)
double	8字节	大约±1.797 693 134 862 315 70E+308(15位有效数字)

四类八种基本数据类型：

整数类型 byte short int(默认) long

浮点型 float double(默认)

字符型 char

布尔型 boolean

变量赋值，例如：

int a=1;
//变量不赋值无法使用
int b;
System.out.println(b); //由于没赋值会报错
int c;
c=2
System.out.println(c); //赋值后正常

类型转换

byte a = 2;
int b = a + 3; //范围小与范围大的运算自动转换成范围大的
byte c = (byte) (a + 3);//如果继续使用范围小的用括号填类型 强制转换
//强制转换可能会造成精度丢失 例如pi 3.1415926...转换成整型
int d = (int) Math.PI; //结果为3

特例，范围相同运算也自动转换为范围大的

byte b1 = 1;
byte b2 = 2;
byte b3 = 1 + 2;
System.out.println(b3); //3 由于1、2常量值确定 因此编译通过
//byte b4=b1 + b2;//编译报错 b1、b2为变量 值不确定，返回类型实际为int
int b4 = b1 + b2;//int正常编译
byte b5 = (byte) (b1 + b2);//加强转正常
System.out.println(b4);

字符char运算

char c = 'd';
//char运算先根据ascii码表转换成数值再运算
System.out.println(c + 0); //100+0=100

运算符

算数运算符

System.out.println(1 + 2 - 3 * 4 / 5);//1
// 加减乘除 除时由于时默认是int类型，因此没保留整数部分
System.out.println(5 % 2);//1 取模 即取两数的余数

赋值运算符

int a=1; //= 最简单赋值运算符
a+=2;//其实就是a=a+2的简写 其他 -=、*=等同理
System.out.println(a);//3

类型强转现象

short s = 1;
s+=1; //变量s类型不变 实际执行强转 s=(short)(s+1);
System.out.println(s);

比较运算符

//>、<、 >=、 <=、 !=、 ==等，返回true与false
System.out.println(1==2); //false
System.out.println(1<=2); //true

逻辑运算符

        System.out.println(1<2&&1==1); //true &&且 两边都满足
        System.out.println(1<2&&1==2); //false
        System.out.println(1<2||1==2); //true ||或者 其中一个满足即可
        System.out.println(1>2||1==2); //false
        System.out.println(!true);//false 取反
        System.out.println(1==1||1/0==1); //true 左边满足即右边不会运算
        System.out.println(1==1|1/0==1); //报错 左边满足 右边继续运算
//        因此建议用双与、双或，它们具有短路的特点，即一方满足另一个将不再运算

三元运算符

int i = (1==2 ? 100 : 200);
System.out.println(i);//200

方法入门

基本格式

修饰符 返回值类型 方法名 (参数列表){
    代码...
    return ;
}

示例

    /*
    * 修饰符例如public、private、protected等代表访问权限
    * static加上表静态方法 不加为非静态 例如main方法就是静态方法
    * 静态方法中调用的方法也是静态的,静态方法先被加载且只会被加载一次
    * void为返回类型为空 即无返回值
    * String[] args即为参数，参数列表可有可无 有时可以传递参数
    * 注意 输出语句调用的方法需有返回值 不能调用void方法
    * */
    public static void main(String[] args) {
        System.out.println(call(10086));
    }

    /**
     *这里返回值为String表示有返回值
     * int no为方法参数
     * return后为返回值
     */
    public static String call(int no) {
        return "拨号：" + no;
    }

方法重载

指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返
回值类型无关。不论修饰词、返回类型咋样，方法名相同且参数列表不同即可。

    public static void main(String[] args) {
        println(123);//123
        println("Hello");//Hello
        println("得分:", 100);//得分:100
        System.out.println(println("得分:", 100L));//得分:100
    }

    public static void println(int a) {
        System.out.println(a);
    }

    private static void println(String a) {
        System.out.println(a);
    }

    public static void println(String a, int b) {
        System.out.println(a + b);
    }

    static String println(String a, long b) {
        return a + b;
    }

方法重写

子类中出现和父类中一模一样的方法(包括返回值类型,方法名,参数列表)
例如：对接口方法进行重写

class Test {
    public static void main(String[] args) {
        new Like() {
            @Override
            public void eat() {
                System.out.println("吃肉肉");
            }
        }.eat();
    }
}

interface Like{
    void eat();
}

不固定参数方法

类型... 表多个该类型参数，此时的foods其实就是个数组，可以通过循环取出它的值

public static void main(String[] args) {
    //我喜欢吃：包子 烧卖 糯米鸡 
    eat("包子","烧卖","糯米鸡");
    eat(); //不固定参数方法 调用时可以为空
}

public static void eat(String... foods){
    System.out.print("我喜欢吃：");
    for (String food : foods) {
        System.out.print(food+" ");
    }
}

JShell

jdk9后新特征，cmd命令行中输入jshell直接进入命令行写java代码，适合新手学习

• /help intro查询帮助
• /exit退出

流程控制语句

简而言之：程序执行顺序影响执行结果，通过控制执行顺序来控制执行结果。

顺序结构

//顺序执行，根据编写的顺序，从上到下运行
System.out.println(1);
System.out.println(2);
System.out.println(3);
//依次输出1、2、3

判断语句

    int num = 90;
    if (num > 0 && num < 60) {
        System.out.println("不及格");
    } else if (num >= 60 && num < 80) {
        System.out.println("良好");
    } else {
        System.out.println("优秀");
    }

选择语句

    String type = "1";
    //选择式
    switch (type){
        case "1":
            System.out.println("打开");
            //这里刚好type为1，由于switch穿透性
            //break不写的话 其下面条件里的语句无论符不符合都会被执行
            break;
        case "0":
            System.out.println("关闭");
            break;
        default:
            System.out.println("其他状态");
    }

循环语句

for

//        循环十次 简析：i从0开始，循环到大于等于10结束，每次循环i+1，称为步进
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
        }
//        步进值为i = i + 2，这样每次循环+2，循环次数由于步进的变化也成了5次
        for (int i = 0; i < 10; i = i + 2) {
            System.out.println(i);
        }

增强for循环

        int[] num={1,2,3,4,5};
        for (int i : num) { //循环的对象可以是数组、集合等
            System.out.println(i); //输出数组中值
        }

jdk8新增forEach .forEach适合遍历list与map，对于数组无法遍历

        List list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.forEach(s->System.out.println(s));

while

        int i=0;
        while (i<10){   //i<10时执行
            i++;    //由于i每次+1 因此会执行10次
            System.out.println(i);
        }

do...while

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

如上代码也执行10次，大致与while执行一致，但两个真一样么？不是，当while中条件不符合时，while一次不会执行，do...while仍然会执行一次！

        int i=0;
        do{
            i++;
            System.out.println(i);
        }while (i>10);

如上代码，虽然i不符合条件，但还是执行了一次，由于条件在执行代码后，因此，这种情况也很容易被理解。总结：while...do会先执行，再判断，如果符合再继续执行，如此往复。而while是先判断，判断不符合就直接不执行

跳出语句

continue; //跳出本次循环

break;//跳出循环

return;//这算不上跳出循环语句，因为在方法里加它会直接跳出方法。

死循环

没结束条件的循环，例如

        while(true){
            System.out.println(System.currentTimeMillis());
        }

for死循环

        for (;;){
            System.out.println(System.currentTimeMillis());
        }

嵌套循环

例如输出一个由*组成的5行10列的矩形

        for (int i = 0; i < 5; i++) {
            for (int i1 = 0; i1 < 10; i1++) {
                System.out.print("*");
            }
            System.out.println();
        }

数组

格式

        int[] arr = new int[3]; //固定长度数组
        int[] arr1 = new int[]{1,2,3,4,5}; //固定内容数组
        int[] arr2 = {1,2,3,4,5};   //同上 固定内容
        arr[0]=100;//数组根据索引赋值
        System.out.println(arr2.length);//输出数组的长度
        System.out.println(arr2[0]);//1 取值索引为0的
        for (int i : arr2) {
//            for循环遍历数组
            System.out.println(i);
        }
        for (int i = 0; i < arr1.length; i++) {
//            根据索引遍历数组
            System.out.println(arr1[i]);
        }

这里注意数组跟集合的索引（下标）都是从0开始的哦！

数组作为参数、返回值

其实main方法就是以数组为参数。当然写这类方法，例如

public void eat(String[] animals){
   //...代码
}

当然前面所介绍的 不固定参数方法其实用的也是数组，方法参数中foods虽然不是数组形式但当数组来调用的

public static void main(String[] args) {
    //我喜欢吃：包子 烧卖 糯米鸡 
    eat("包子","烧卖","糯米鸡");
    eat(); //不固定参数方法 调用时可以为空
}

public static void eat(String... foods){
    System.out.print("我喜欢吃：");
    //这里foods其实就是数组
    for (String food : foods) {
        System.out.print(food+" ");
    }
}

数组操作案例

获取最大值

以下变量max相当于一个擂台的颁奖台，谁大就往上放，然后它再继续跟其它数比较

        int[] arr = {1, 2, 3, 4, 5};
        //定义变量，保存数组中0索引的元素
        int max = arr[0];
        //遍历数组，取出每个元素
        for (int i = 0; i < arr.length; i++) {
        //遍历到的元素和变量max比较
        //如果数组元素大于max
            if (arr[i] > max) {
        //max记录住大值
                max = arr[i];
            }
        }
        System.out.println("数组最大值是： " + max);

数组反转

建个临时变量，小的复制给temp，然后大的复制给小的，temp再赋值给大的（其实也就是小的赋值给大的）

        int[] arr = { 1, 2, 3, 4, 5 };
        /*
        循环中定义变量min=0最小索引
        max=arr.length‐1最大索引
        min++,max‐‐
        */
        for (int min = 0, max = arr.length - 1; min <= max; min++, max--) {
        //利用第三方变量完成数组中的元素交换
            int temp = arr[min];
            arr[min] = arr[max];
            arr[max] = temp;
        }
        // 反转后，遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }