Java之基础语法

时间 2020-07-06

标签 java 基础语法栏目 Java 繁體版

原文原文链接

1.Java的语言概述

Java基础知识的图解

(1)软件开发介绍

1.软件开发:

软件即一系列按照特定顺序组织的计算机数据和指令的集合。有系统软件和应用软件之分。java

2.人机交互的方式：

》图形化界面（简称GUI）是指采用图形方式显示的计算机操做用户界面。编程

》命令行界面（简称CLI）是用户经过键盘输入指令，计算机获得指令后，予以执行。数组

3.经常使用的DOS命令

dir : 列出当前目录下的文件以及文件夹
md ：建立目录
rd ：删除目录
cd ：进入指定的目录
cd.. : 退回到上一级目录
cd : 退回到根目录
del ：删除文件
exit : 退出DOS命令窗口

(2)计算机编程语言介绍

1.语言发展

第一代语言：机器语言,指令是以二进制代码形式存在。app

第二代语言：汇编语言,使用助记符表示一条机器指令。编程语言

第三代语言：高级语言,是种独立于机器，面向对象或者对象的语言。模块化

面向过程的语言：C,Pascal、Fortran
面向对象的语言：Java,JS,Python,Scala..

(3)Java语言的迭代概述

1991年 Green项目，开发语言最初命名为Oak (橡树)工具

1994年，开发组意识到Oak 很是适合于互联网开发工具

1996年，发布JDK 1.0，约8.3万个网页应用Java技术来制做编码

1997年，发布JDK 1.1，JavaOne会议召开，创当时全球同类会议规模之最spa

1998年，发布JDK 1.2，同年发布企业平台J2EE

1999年，Java分红J2SE、J2EE和J2ME，JSP/Servlet技术诞生

2004年，发布里程碑式版本：JDK 1.5，为突出此版本的重要性，改名为JDK 5.0

2005年，J2SE -> JavaSE，J2EE -> JavaEE，J2ME -> JavaME

2009年，Oracle公司收购SUN，交易价格74亿美圆

2011年，发布JDK 7.0

2014年，发布JDK 8.0，是继JDK 5.0以来变化最大的版本

2017年，发布JDK 9.0，最大限度实现模块化

2018年3月，发布JDK 10.0，版本号也称为18.3

2018年9月，发布JDK 11.0，版本号也称为18.9

(4)运行机制及运行过程

1.Java语言的特色：

面向对象
两个基本概念：类、对象
三大特性：封装、继承、多态
健壮性
① 去除了C语言中的指针 ②自动的垃圾回收机制 -->仍然会出现内存溢出、内存泄漏。
跨平台性
一次编译处处运行“Write once，Run Anywhere”
Java的虚拟机JVM，不一样的平台，提供不一样的虚拟机。

(5)JDK JRE JVM

1.什么是JDK、JRE、JVM，以及三者的关系

JDK是提供给Java开发人员使用，包含了Java的开发工具。
JRE是Java的运行环境，包括了Java虚拟机和Java程序所需的核心类库等。
JVM是一个虚拟的计算机，具备指令集并使用不一样的存储区域。负责执行指令，管理数据、内存、寄存器。

(6)第一个程序HelloWorld

1.第一个开发体验

1.1编写

//建立一个后缀名为.java的文件：HelloWorld.java
public class HelloWorld{
    public static void main(String[]args){
        System.out.println("HelloWorld");
    }
}

1.2编译

javac HelloWolrd.java
会生成一个后缀名为.class的字节码文件

1.3运行

java HelloWorld
注意要去掉.class后缀名

1.4小结

Java源文件以“.java”为后缀名。
Java应用程序的执行入口是main()方法。
Java语言严格区分大小写。
Java每一个语句都以“;”结束。
大括号都是成对出现的，缺一不可。

2.常见的Bug及解决方法

(7)注释和API文档

1.三种注释类型

1.单行注释 格式： //注释文字
2.多行注释 格式：/*注释文字*/
单行和多行注释，不会被JVM解释执行，多行注释不容许嵌套。
3.文档注释 格式/**注释文字*/
文档注释能够被JDK提供的工具javadoc所解析，生成网页形式的说明文档

2.API文档

API: application programming interface。习惯上：将语言提供的类库，都称为API.
API文档：针对于提供的类库如何使用，给的一个说明书。相似于《新华字典》

2.Java基本语法

(1)关键字和标识符

1.关键字：

被Java语言赋予了特殊含义，用作专门用途的字符串，关键字全部的字母小写。

2.保留字

现有Java版本还没有使用，但之后版本可能会做为关键字使用。（goto、const）

3.标识符

3.1定义

Java对各类变量、方法和类等要素命名时使用的字符序列为标识符。（本身起名字的地方都叫标识符）

3.2标识符命名规则

1.由26个英文字母大小写，0-9，_或$组成
2.数字不可开头
3.不可使用关键字和保留字，但能包含关键字和保留字
4.Java中严格区分大小写，长度无限制
5.标识符中不能够包含空格

3.3标识符命名规范

包名：多单词组成时全部单词都小写
类名、接口名：多单词组成时，全部单词首字母都大写
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每一个单词首字母大写
常量名：全部字母都大写，多单词组成时用_下划线隔开

(2)变量

1.1变量的概念

内存中的一个存储区域
该区域的数据能够在同一类型范围不断变化
变量时程序中最基本的储存单元，包含变量类型、变量名和储存的值

1.2使用变量要注意

Java中每一个变量必须先声明，后使用
使用变量名来访问这块区域的数据
变量的做用域：其定义所在的一对{}内
变量只有在其做用域才有效
同一个做用域中不可使变量重名

1.3变量的声明与赋值

声明变量 语法： <数据类型><变量名称>;
                int test;
       
变量的赋值 语法： <变量名称> = <值>;
                test = 10;
            
声明和赋值变量 语法：<数据类型><变量名称> = <值>；;
                int test = 10;

2.1变量的分类

在方法体外，类体内声明变量称为成员变量。
在方法体内部声明的变量称为局部变量。

2.2 8种数据类型

类型          储存空间            范围
(1)整数
byte          1字节            -128~127
short         2字节            正负3万多
int           4字节            正负21亿
整数默认的类型是int类型
long          8字节            19位数字
表示long类型数据后面须要加L/l
(2)浮点数
float         4字节      
表示float类型数据后面须要加F/f，取值范围大于8字节的long
double        8字节   
浮点数默认是double类型
(3)字符
char          2字节
(4)布尔
boolean       1字节   取值为true或者false

2.3定义8种数据类型

public class Type{
    public static void main(String[]args){
        //1.整数类型定义byte、short、int、long
        byte a = 10;
        short b = 11;
        int c = 12;
        long d = 1000L;//long类型要加上L/l
        //2.浮点数定义
        float f = 1.23F；//float类型要加上F/f
        double e = 2.6；
        //3.char类型
        char r = 'A';
        //char类型中只能放一个字符 不可为空
        //4.布尔类型
        boolean lean = true；//取值只有true/false
    }
}

3.1自动数据类型的转换

容量小的类型自动转换成容量大的数据类型。

byte、short、char之间不会互相转换，三者计算会首先转换成int类型。
boolean类型不能参与其余数据类型的运算。
当把任何基本数据的值和字符串(String)进行链接运算时(+),基本数据类型的值将自动转化为字符串类型。

int + int
    int + long ==> long + long  (把int转换成long: 从小到大,自动类型转换)
    
    例子1：
    int i = 1; 
    byte b = 2; 
    int c = i + b； i是int型，b是byte型，二者运算自动类型转换为int型

3.2强制类型转换

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型，使用时要加上强转符(),但可能形成精度下降或溢出。

转后类型 变量名称 = (转后类型)转前数据或者变量;
    long类型(8个字节)的数字10:
    long num = 10L;
    long类型强制类型转换成int类型(4个字节):
    int a = (int)num;//把num中的数据强制类型转换成int类型,并把结果赋值给int变量a

4.进制

进制的概念：逢几进一就叫作几进制
进制的分类：
    十进制:    逢十进一        每位的数字0-9
    二进制:    逢二进一        每位的数字0-1
    八进制:    逢八进一        每位的数字0-7
    十六进制:  逢十六进一      每位的数字0-9,10(A/a),11(B/b),12(C/c),13(D/d),14(E/e),15(F/f)

4.1进制的转换

1.二进制转十进制(8421编码):    
    (二进制数字的每一位(从右向左 )上隐藏了一个2的多少次方,第1位是2的0次方,第2位是2的1次方...):
    1101 = 1*2^0 + 0*2^1 + 1*2^2 + 1*2^3
         = 1*1 + 0*2 + 1*4 + 1*8
       = 1 + 0 + 4 + 8
         = 13
      
    1111 = 1*2^0 + 1*2^1 + 1*2^2 + 1*2^3
       = 1*1 + 1*2 + 1*4 + 1*8
         = 1 + 2 + 4 + 8
         = 15
        
      
  2.十进制转二进制: 除以2取余数,倒过来写
    十进制的13转换成二进制:    1101
    十进制的75转换成二进制:    1001011

(3)运算符

1.算术运算符

算术运算符： + - + - * / % (前)++ (后)++ (前)-- (后)-- +

【经典代码】

//除号：/
        int num1 = 12;
        int num2 = 5;
        int result1 = num1 / num2;
        System.out.println(result1);//2
        // %:取余运算
        //结果的符号与被模数的符号相同
        //开发中，常用%来判断可否被除尽的状况。
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1 % n1 = " + m1 % n1);

        int m2 = -12;
        int n2 = 5;
        System.out.println("m2 % n2 = " + m2 % n2);

        int m3 = 12;
        int n3 = -5;
        System.out.println("m3 % n3 = " + m3 % n3);

        int m4 = -12;
        int n4 = -5;
        System.out.println("m4 % n4 = " + m4 % n4);
        //(前)++ :先自增1，后运算
        //(后)++ :先运算，后自增1
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1 = " + a1 + ",b1 = " + b1);
        
        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2 = " + a2 + ",b2 = " + b2);
        
        int a3 = 10;
        ++a3;//a3++;
        int b3 = a3;
        //(前)-- :先自减1，后运算
        //(后)-- :先运算，后自减1
        
        int a4 = 10;
        int b4 = a4--;//int b4 = --a4;
        System.out.println("a4 = " + a4 + ",b4 = " + b4);

【特别说明】

(前)++ :先自增1，后运算
(后)++ :先运算，后自增1
(前)-- :先自减1，后运算
(后)-- :先运算，后自减1
链接符：+：只能使用在String与其余数据类型变量之间使用。

2.赋值运算符

赋值运算符：= += -= *= /= %=

【经典代码】

int i2,j2;
        //连续赋值
        i2 = j2 = 10;
        //***************
        int i3 = 10,j3 = 20;
        int num1 = 10;
        num1 += 2;//num1 = num1 + 2;
        System.out.println(num1);//12

        int num2 = 12;
        num2 %= 5;//num2 = num2 % 5;
        System.out.println(num2);

        short s1 = 10;
        //s1 = s1 + 2;//编译失败
        s1 += 2;//结论：不会改变变量自己的数据类型
        System.out.println(s1);

运算的结果不会改变变量自己的数据类型

3.比较运算符

比较运算符（关系运算符）: == != > < >= <= instanceof

【经典代码】

int i = 10;
        int j = 20;

        System.out.println(i == j);//false
        System.out.println(i = j);//20

        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b2 == b1);//false
        System.out.println(b2 = b1);//true

比较运算符的结果是boolean类型
（ > < >= <= :只能使用在数值类型的数据之间。）
== 和 !=: 不只可使用在数值类型数据之间，还可使用在其余引用类型变量之间。

4.逻辑运算符

逻辑运算符：& && | || ! ^

【经典代码】

boolean b1 = true;
        b1 = false;
        int num1 = 10;
        if(b1 & (num1++ > 0)){
            System.out.println("我如今在北京");
        }else{
            System.out.println("我如今在南京");
        }

        System.out.println("num1 = " + num1);
        
        & && 的区别：当符号左边是false时，&继续执行符号右边的运算，&&再也不执行符号右边的运算。
        | ||同理↑

5.位运算符

位运算符：<< >> >>> & | ^ ~

【经典代码】

int i = 21;
        i = -21;
        System.out.println("i << 2 :" + (i << 2));
        System.out.println("i << 3 :" + (i << 3));
        System.out.println("i << 27 :" + (i << 27));

        int m = 12;
        int n = 5;
        System.out.println("m & n :" + (m & n));
        System.out.println("m | n :" + (m | n));
        System.out.println("m ^ n :" + (m ^ n));

位运算符操做的都是整型的数据
<< ：在必定范围内，每向左移1位，至关于 * 2 >>:在必定范围内，每向右移1位，至关于 / 2

6.三元运算符

格式：（条件运算符）？表达式1 ：表达式2

【经典代码】

1.获取两个整数的最大值

int a = 5;
int b = 6;
int max = (a > b) ? a : b;

2.获取三个数的最大值

int a = 1;
int b = 2;
int c = 3;
int temp = (a > b) ? a : b; //先判断两个数的值赋值给一个变量temp
int max = (temp > c) ? temp : c; //再判断temp与c的大小

条件表达式的结果为boolean类型
根据条件表达式真或假，决定执行表达式1，仍是表达式2.
若是表达式为true，则执行表达式1。
若是表达式为false，则执行表达式2。
表达式1 和表达式2要求是一致的。
三元运算符能够嵌套使用
凡是可使用三元运算符的地方，均可以改写为if-else反之，不成立。
若是程序既可使用三元运算符，又可使用if-else结构，那么优先选择三元运算符。缘由：简洁、执行效率高。

(4)流程控制

1.分支语句

1.1 if-else条件判断结构

书写方法：

结构1：
if(条件表达式){
    执行表达式
}

结构2：（2选1）
if(条件表达式){
    执行表达式1
}else{
    执行表达式2
}

结构3：(n选1)
if(条件表达式1){
    执行表达式1
}else if(条件表达式2){

...
}else{
    执行表达式n
}

else 结构是可选的。
针对于条件表达式：
- 若是多个条件表达式之间是“互斥”关系(或没有交集的关系),哪一个判断和执行语句声明在上面仍是下面，无所谓。
- 若是多个条件表达式之间有交集的关系，须要根据实际状况，考虑清楚应该将哪一个结构声明在上面。
- 若是多个条件表达式之间有包含的关系，一般状况下，须要将范围小的声明在范围大的上面。不然，范围小的就没机会执行了。
if-else结构是能够相互嵌套的。
若是if-else结构中的执行语句只有一行时，对应的一对{}能够省略的。可是，不建议省略。

1.2 switch-case选择结构

switch(表达式){
case 常量1:
    执行语句1;
    //break;
case 常量2:
    执行语句2;
    //break;
...
default:
    执行语句n;
    //break;
}

根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
- 当调用完执行语句之后，则仍然继续向下执行其余case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
break,可使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
switch结构中的表达式，只能是以下的6种数据类型之一： byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
case 以后只能声明常量。不能声明范围。
break关键字是可选的。
default:至关于if-else结构中的else.
default结构是可选的，并且位置是灵活的。

补充：

若是switch-case结构中的多个case的执行语句相同，则能够考虑进行合并。
break在switch-case中是可选的

2.循环结构

2.1. 循环结构的四要素

① 初始化条件 ② 循环条件 --->是boolean类型 ③ 循环体 ④ 迭代条件说明：一般状况下，循环结束都是由于②中循环条件返回false了。

2.2三种循环结构

for循环结构

for(①;②;④){
    ③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

while循环结构

①
while(②){
    ③;
    ④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

for和while循环总结：

开发中，基本上咱们都会从for、while中进行选择，实现循环结构。
for循环和while循环是能够相互转换的！区别：for循环和while循环的初始化条件部分的做用范围不一样。
咱们写程序，要避免出现死循环。

do - while循环结构

①
do{
    ③
    ④
}while(②)

说明：

do-while循环至少会执行一次循环体！
开发中，使用for和while更多一些。较少使用do-while
数组循环比遍历一般用for循环
触发条件复杂的用while循环

3. “无限循环”结构: while(true) 或 for(;;)

如何结束一个循环结构？

方式一：当循环条件是false时
方式二：在循环体中，执行break

4.嵌套循环

嵌套循环:将一个循环结构A声明在另外一个循环结构B的循环体中,就构成了嵌套循环内层循环：循环结构A 外层循环：循环结构B

说明： ① 内层循环结构遍历一遍，只至关于外层循环循环体执行了一次 ② 假设外层循环须要执行m次，内层循环须要执行n次。此时内层循环的循环体一共执行了m * n次 ③ 外层循环控制行数，内层循环控制列数

/*
        ******
        ******
        ******
        ******
        */
        for(int j = 1;j <= 4;j++ ){
            for(int i = 1;i <= 6;i++){
                System.out.print('*');
            }
            System.out.println();
        }
        //练习二：
        /*            i(行号)        j(*的个数)
        *             1            1
        **            2            2
        ***           3            3
        ****          4            4
        *****         5            5
        */

        for(int i = 1;i <= 5;i++){//控制行数
            for(int j = 1;j <= i;j++){//控制列数
                System.out.print("*");
            
            }
            System.out.println();
        }

3. 关键字：break和continue

break和continue关键字的使用

	使用范围	循环中的做用(不一样点)	相同点
break	swiltch-case循环结构中	结束当前循环	关键字后面不能声明执行语句
continue	循环结构中	结束当前循环	关键字后面不能声明执行语句

补充：带标签的break和continue的使用

4. 补充：Scanner类的应用

如何从键盘获取不一样类型的变量：须要使用Scanner类

具体实现步骤：

导包：import java.util.Scanner;
Scanner的实例化:Scanner scan = new Scanner(System.in);
调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量

注意：须要根据相应的方法，来输入指定类型的值。若是输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException致使程序终止

*/
//1.导包：import java.util.Scanner;
import java.util.Scanner;

class ScannerTest{
    
    public static void main(String[] args){
        //2.Scanner的实例化
        Scanner scan = new Scanner(System.in);
        
        //3.调用Scanner类的相关方法
        System.out.println("请输入你的姓名：");
        String name = scan.next();
        System.out.println(name);

        System.out.println("请输入你的芳龄：");
        int age = scan.nextInt();
        System.out.println(age);

        System.out.println("请输入你的体重：");
        double weight = scan.nextDouble();
        System.out.println(weight);

        System.out.println("你是否相中我了呢？(true/false)");
        boolean isLove = scan.nextBoolean();
        System.out.println(isLove);

        //对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串
        System.out.println("请输入你的性别：(男/女)");
        String gender = scan.next();//"男"
        char genderChar = gender.charAt(0);//获取索引为0位置上的字符
        System.out.println(genderChar);    
    }
}