Java入门基础知识

作者: 极四维 | 来源:发表于2020-05-16 21:49 被阅读0次

Java学习入门基础推荐
找工作必备技能
Java入门基础知识点整理大放送，推荐保存
Java爬虫高级教程
java程序员必须知道的21个核心技术
立一个目标，用半年去证明
Java基础知识入门
Java入门基础知识
外挂基础知识入门
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。

配置环境变量

计算机鼠标右键,选择属性
选择高级系统设置
高级选项卡，点击环境变量
点击新建，创建新的环境变量
变量名输入 JAVA_HOME ，变量值输入JDK9的安装目录 c:\Java9\jdk-9.0.1（这里只是举例请填写真实路径）
选中 Path 环境变量，双击或者点击编辑
在变量值的最前面，键入 %JAVA_HOME%\bin; 分号必须要写，必须是英文格式
环境变量配置完成，重新开启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（即-2³¹ ~ 2³¹-1）
short	2字节	-32 768 ~ 32 767
long	8字节	-9 223 372 036 854 775 808 ~ 9 223 372 036 854 775 807（即-2⁶³ ~ 2⁶³-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<Integer> 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]);
        }

Java学习入门基础推荐
给你推荐一个写得非常用心的Java基础教程：Java入门基础教程 | 天码营这个教程将Java的入门基础知识贯穿...
找工作必备技能
基础知识Java和JQuery SpringMVC 源码学习-入门 Mysql存储过程，Mysql高级查询相关SQ...
Java入门基础知识点整理大放送，推荐保存
为了方便大家学习Java，理顺Java技术知识点，也可以助您尽快的努力成长起来，小编整理了以下Java入门基础知识...
Java爬虫高级教程
作为网络爬虫的入门采用Java开发语言，内容涵盖了网络爬虫的原理以及开发逻辑，Java网络爬虫基础知识，网络抓包介...
java程序员必须知道的21个核心技术
Java程序员必须知道的21个核心技术，分享一些java基础知识点相关的，所以也希望能分享给刚刚入门的Java程序...
立一个目标，用半年去证明
目标一：学会yii2 并对php的基础知识 mysql 并加以巩固目标二： java 入门目标三：随心所...
Java基础知识入门
入门 1. 规范 l 深刻理解面向对象的思想 l 注重代码的练习，量变产生质变 l 代码格式要规范 2. 计算机常...
Java入门基础知识
计算机基础二进制计算机中的数据不同于人们生活中的数据，人们生活采用十进制数，而计算机中全部采用...
外挂基础知识入门
外挂基础知识入门
Java线程简述
下面总结一下这段时间学习java线程的一些入门基础知识. 一.什么是线程? 这个问题可以说是每个刚涉及java线...

Java入门基础知识

计算机基础

二进制

进制转换

十进制转二进制

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

字节

JAVA环境

JRE 和 JDK

配置环境变量

基础知识

第一个Java程序

关键字keywords

标识符

注释

数据类型

类型转换

运算符

算数运算符

赋值运算符

比较运算符

逻辑运算符

三元运算符

方法入门

基本格式

方法重载

方法重写

不固定参数方法

JShell

流程控制语句

顺序结构

判断语句

选择语句

循环语句

for

while

do...while

跳出语句

死循环

嵌套循环

数组

格式

数组作为参数、返回值

数组操作案例

获取最大值

数组反转

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读