java基础语法1 -狂神说

JAVA基础语法

注释、标识符、关键字

注释

• 平时我们编写代码，如果代码量小的时候，我们可以看懂，如果多的时候，时间久后容易看不懂。
• 注释不会被执行，是我们写给写代码人看的
• 书写代码是个很好的习惯
• 平时写代码一定要注意规范

java注解有三种：

1. 单行注释//
2. 多行注释/* */
3. 文档注释/** **/
   idea快捷键ctrl+/
   

关键字

关键字不能修改名字

标识符

JAVA的组成部分都需要名字、类名、变量名以及方法名都称为表示符

1 、类名 2、方法名 3、变量名；

标识符注意点：

• 所有的标识符都应该以字母（A-Z或者a-z），所有的标识符都应该以字母（A-Z或者a-z），美元符($)，或者下划线（_）开始;"大小写十分敏感“
• 首字母之后可以是字母（A-Z或者a-z），美元符($)，或者下划线（_）或者数字的任何字符组合;“特殊符号不能使用”
• 不能使用关键字作为变量名或者方法名。
  合法标识符举例：age、 $salary、 _value、 __1_value
• 非法标识符举例：123abc、 -salary、 #abc
• 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很Low

数据类型

强类型语言

• 要求变量的使用严格符合规定，所有变量都必须先定以后才能使用；安全性高，但是速度慢。

弱类型语言

• 弱类型语言也称为弱类型定义语言。与强类型定义相反。像vb，php等就属于弱类型语言·

类型分类

Java的数据类型分为俩大类

1. 基本类型

整数 ：
- byte 1字节 8位 java范围2（7）-1到-2（7）
- short 2字节 很少使用 2（15）-1到-2（15）
- int 4字节 最常用 2（31）-1到-2（31）
- long 8字节 长整形 2（63）-1到-2（63）

小数：
- float 4字节
- double 8字节

其它
char 2字节 无符号 2（15）-1
boolean 1字节 代表真true or 假false

2. 引用类型
   String 字符串

字节

• 位（bit）:是计算机 内部数据 储存的最小单位，11001100是一个八位二进制数。

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

• 1B（byte,字节） = 8bit（位）

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

• 1bit表示1位

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

• 1024B=1KB

• 1024KB=1M

1024M=1G

类型转换

• 由于java是强类型语言，所有需要运算的时候的，需要用到类型转换。

低----------------------------------------------------------》高

byte， short， char -> int -> long -> float -> double
​ （小数的优先级高于整数）

• 运算中，不同类型的数据先转换为同一类型，然后进行运算。

-强制类型转换 高-->低

自动类型转换

• 由低到高直接输入，无需强制转换
• 注意
  1. 不能对布尔值进行转换
  2. 不能把对象类型转化为不相关的类型
  3. 在把高容量转换为低容量时，需要强制转换
  4. 转换的时候可能存在内存溢出或者精度问题！

char 转化为 int

溢出问题

变量

• 变量是什么：就是可以变化的量！
• Java是一种强类型语言，每个变量都必须声明其类型。
• java变量是程序中最基层的存储单元，其要素包括变量名，变量类型和作用域。
• 注意事项：
  1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型
  2. 变量名必须是合法的标识符
  3. 变量声明是一条完整的语句，因此每个声明都必须以分号结束。

变量的作用域

类变量

在类里，整个类里可以使用，前面必须加static；“static int a = 666”

实例变量

在类里，从属于对象；“int age;//0”

如果不自行初始化，这个类型的默认值 0,0.0

布尔值：默认是false；除了基本类型，其他的默认值都是null；

局部变量

在方法中，使用时必须声明和初始化值；“int cba = 666;"

常量

• 常量（Constant)：初始化（initialize）后不能再改变值！不会变动的值。

• 所谓常量可以理解成一种特殊的变量，他的值被设定后，在程序运行过程中不允许被改变。

final 常量名 = 值；
final double PI = 3.14;

• 常量名一般使用大写字符。

变量的命名规范

• 所有变量、方法、类名：见名其意

• 类成员变量：首字母小写和驼峰原则：monthSalary

• 除了第一个单词外，后面的单词首字母大写

• 局部变量：首字母小写和驼峰原则

• 常量：大写字母和下划线 MAX_VALUE

• 类名：首字母大写和驼峰原则：Man,GoodMan

• 方法名：首字母小写和驼峰原则：run(),runRun()

运算符

Java语言支持如下运算符：优先级：最好使用（）

• 算术运算符：+，-，*，/，%（余），++（自增），–（自减）；
• 赋值运算符：=；
• 关系运算符：> , < , >= , <= , == , != , instanceof；
  计算结果一定是true or false；以后会和if一起用
• 逻辑运算符：&& （与）， ||（或）， ！（非）；
  计算结果一定是true or false
• 位运算符：&，|，^，~，>>，<<，>>>；
• 条件运算符：？，：；
• 扩展赋值运算符：+=，-=，*=，/=；

算术运算符

++（自增）
a++ ： ++在后时，先赋值，再自增；
++a：++在前时，先自增，再赋值；

int a = 5;
int b = a++;//a++加在后，先给b赋值，再自增；
System.out.println(a);//a=6
System.out.println(b);//b=5
================================================
int c = ++a;//++a加在前，先自增，再赋值给c；
System.out.println(a);//a=6;
System.out.println(c);//c=6;

-（自减）同理

注意事项

• 算术运算使用中，有一个为long或者double类型，其结果为long或者double类型，不然为int类型
• 很多运算java，会使用一些很多工具类来操作

逻辑运算符

• &&（与）：逻辑与运算，来个变量都为真，结果才为true
• ||（或）：逻辑或运算，两个变量有一个为真，结果才为true
• ！（非）：如果是真，则变为假，如果是假则变为真

int q = 10;
int  w = 20;
System.out.println(q<w && w>30);//（false)，q<w正确，w>30错误,
// 可解释为:q<w与w>30同时两条成立，结果为true，所以最后结果为"false"
System.out.println(q<w || w>30);//（true),q<w正确，w>30错误,
// 可以解释为:q<w或w>30其中一条成立，结果就为true，所以最后结果为"true"
System.out.println(!(q<w));//（false),q<w正确。
// 可以解释为:q应该不（非）小于w，但是实际上q<w，所以为”false"

断路运算

当前面为“false”时，后面的将不执行，只有“true”才会运行，这就叫短路运算。

int z = 5;
boolean x = (z<4)&&(z++<4);//由于（z<4）不成立为false，（z++<4)就不运行
System.out.println(x);//(false)
System.out.println(z);//(5)由于（z++<4)没有运算，所以z没有自增

位运算符

& （1）：全部为1才为1，否者为0

| （0）：全部为0才为0，否者为1

^（同0）：相同为0，否者为1

~（取反）：取二进制相反的数

 A = 1100 0011
 B = 1001 0110
---------------
A&B= 1000 0010
A|B= 1101 0111
A^B= 0101 0101
~B = 0110 1001

"<<"二进制左位移=代表*2

">>"二进制右位移=代表/2

扩展运算符

+=，-=，*=，/=;()

int a = 5, b = 10;
a+=b;//a=a+b(15)
a-=b;//a=a-b(-5)
a*=b;//a=a*b(50)
a/=b;//a=a/b(0.5)

字符串连接符

在“+”号前出现string类型时，他会把“+”后面的一操作数，转换成steing类型，进行拼接

 int a = 5, b = 20;
System.out.println("yes"+a+b);//(yes520)
System.out.println(a+b+"yes");//(25yes)
System.out.println("yes"+(a+b));//(yes25)
System.out.println(""+a+b+"yes");//(520yes)
System.out.println(""+a+b+(a+b)+"yes");//(52025yes)

条件运算符

x？ y：z //x值如果为true=y，如果为false=z；

int score = 60;
int xm = 70;
int xg = 49;
int xh = 60;
System.out.println("xm:"+(xm>=score ?"及格":"不及格"));//(xm:及格)
System.out.println("xg:"+(xg>=score ?"及格":"不及格"));//(xg:及格)
System.out.println("xh:"+(xh>=score ?"及格":"不及格"));//(xh:及格)

后期可以使用if做

包机制

“包的本质就是文件夹”

• 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
• 包语法的语法格式为：

package pkg1[.pkg2[.pkg3...]]//定义包

• 一般利用公司域名倒置作为包名；
• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import"完成此功能

import package1[.package2...].(classname|*);//导入包，*导入这个包下所以的类

尽量不要把包名重复

JavaDoc

• javadoc命令是用来生成自己API文档的
• 参数信息
  - @author作者名
  - @version版本号
  - @since 指明需要最早使用的jdk版本
  - @param 参数名
  - @return 返回值情况
  - @throws 异常抛出情况

/**
 * @author ssxxz
 * @version 1.0
 * @since 1.8
 */

JAVA流量控制

用户交互Scanner

Scanner

• 之前我们学习的基本语法中，我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获得用户的输入。java.util.Scanner是java5特性，我们可以通过Scanner类来获取用户的输入。
• 基本语法

Scanner s = new Scanner(System.in);

• 通过 Scanner 类的next() 与 nextLine() 方法获取输入的字符串，
  ​ 在读取前我们一般需要使用 hasNext() 与 hasNextLine() 判断是否还有输入的数据。

• next():

  1. 一定要读取到有效字符后才可以结束输入。
  2. 对输入有效字符之前遇到空白，next（）方法会子弟用去掉
  3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
  4. next（）不能得到带有空格的字符串。

• nestLine（）：
  1. 以Enter为结束符也就是说nextLine()方法返回的是输入回车之前的所有字符。
  2. 可以获得空白。

import java.util.Scanner;
public class Demo03 {
    public static void main(String[] args) {
        Scanner ssxxz = new Scanner(System.in); //创建一个扫描器对象，用于接受键盘数据
        System.out.println("请输入：");
            String str = ssxxz.nextLine();//使用nextLine方式接收
            System.out.println("输出为："+str);//程序会等待用户输入完毕
        //凡是属于IO流的类，如果不关闭会一直占用资源，要养成好习惯用完就关闭掉
        ssxxz.close();
    }
}

if判断语句，while循环语句
if

import java.util.Scanner;
public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //从键盘接收数据
        int i = 0;
        float f = 0.0f;
        System.out.println("请输入整数：");
        //如果...那么...
        if (scanner.hasNextInt()){
            i = scanner.nextInt();
            System.out.println("整数数据："+i);
        }else{
            System.out.println("输入的不是整数数据！");
        }
        System.out.println("请输入小数数据：");
        if (scanner.hasNextFloat()){
            f = scanner.nextFloat();
            System.out.println("小数数据："+f);
        }else{
            System.out.println("输入的不是小数数据！");
        }
        scanner.close();
    }

}

while

import java.util.Scanner;
public class Demo05 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果。
        Scanner scanner = new Scanner(System.in);
        //和
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;

        System.out.println("请输入数据：");
        //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        while(scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            m = m +1;//m++
            sum = sum+x;
            System.out.println("当前是第："+m+"个，sun总数为："+sum);
        }
        System.out.println(m+"个数的和为："+sum);
        System.out.println(m+"个数的平均值是："+(sum/m));
      scanner.close();
    }
}

顺序结构

• JAVA的基本结构就是顺序结构，排除特别指明，否则就是按照顺序一句一句执行。
• 顺序结构是最简单的算法结构。
• 语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。

选择结构

• if单选结构
• if双选择结构
• if多选择结构
• 嵌套的if结构
• switch多选择结构

if单选择结构

• 我的很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示。
• 语法：

if(布尔表达式)｛
    //如果布尔表达式为true将执行的语句
    ｝

语句：

import java.util.Scanner;
public class ifDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入咒语：");
        String s = scanner.nextLine();
        //equals:判断字符串是否相等
        if (s.equals("Hello")){
            System.out.println(s);
        }
        System.out.println("End");
        scanner.close();
    }
}

if双选择结构

• 语法

if（布尔表达式）｛
    //如果布尔表达式的值为true
    ｝else{
    //如果布尔表达式的值为false
}

语句：

import java.util.Scanner;
public class IfDemo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的成绩：");
        int c = scanner.nextInt();
        if (c>=60){
            System.out.println("及格");
        }else{
            System.out.println("不及格");
        }
        scanner.close();
    }
}

if多选择结构

• 我们发现刚才的代码不符合时间情况，真实的情况还可能存在ABCD,存在区间多级判断，比如90-100就是A，80-90就是B…等等，在生活中我们很多时候的选择也补仅仅只有两个，所以我们需要一个多选择结构来处理这类问题!
• 语法

if（布尔表达式1）｛
    //如果布尔表达式1的值为true执行代码
    ｝else if（布尔表达式2）｛
    //如果布尔表达式2的值为true执行代码
    ｝else if（布尔表达式3）｛
    //如果布尔表达式3的值为true执行代码
    ｝else{
    //如果以上布尔表达式都不为true执行代码
}

if 语句最多有1个 else 语句，else 语句在所以 else if 语句之后。

if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。

一旦其中一个 else if 语句检测为 true， 其它的 else if 以及 else 语句都将跳过执行。

嵌套的if结构

• 使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。你可以像 if 语句一样嵌套 else if…else。
• 语法：

if(布尔表达式 1){
    //如果布尔表达式 1的值为true执行代码
    if（布尔表达式 2）{
        //如果布尔表达式 2的值为true执行代码
    }
}

switch多选择结果

• 多选择结构还有一个实现方式就是 switch case 语句。
• switch case 语句判断一个变量与一个系列值中某个值是否相等，每个值称为一个分支。

//switch 匹配一个具体的值
switch(expression){
    case value :
        //语句
        break://可选，主要功能防止case穿透
    case value:
        //语句
        breck://
     //你可以有任意数量的case语句
    default://可选，当出现无法匹配任何case时，可以用default表达
        //语句
}

public static void main(String[] args){
     char grade = 'B';
     switch (grade){
     case 'A':
     System.out.println("优秀")；
     break;
     case 'B':
     System.out.println("及格")；
     break;
     case 'C':
     System.out.println("一般")；
     break;
     default:
     System.out.println("未知等级")
}

循环结构

- switchi 语句中的变量类型可以是：

- byte、short、int 或者 chat.
- **从 Java SE 7开始**
- **switch 支持字符串 String 类型**
- 同时 case 标签必须为字符串常量或字符量

### 循环结构

- while 循环
- do...while 循环
- for 循环



- 在Java5中引入了一种主要用于数组的增强型for循环。

#### while循环

- while是最基层的循环，它的结构为：

```java
while(布尔表达式){
   //循环内容
}

• 只有布尔表达式为 true,循环就会一直执行下去。
• 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失败的方式来结束循环。
• 少部分情况需要循环一直执行，比如服务器的请求响应监听等。
• 循环条件一直未true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环，会影响程序性能或者造成程序卡死崩溃！

计算1+2+3+…+100=？

public class whileDemo01 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        while(i<=100){
            sum = sum+i;
            i++;
            System.out.println(sum);
        }
        System.out.println(sum);
    }
}

do...while循环

• 对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
• do … while 循环和 while 循环相似，不同的是， do … while 循环至少会执行一次

do{
    //代码语句
    while(布尔表达式)
}

While 和 do-While 的区别：

• while先判断后执行。dowhile是先执行后判断！
• Do … while 总是保证循环体会被至少执行一次！这是他们的主要差别。

public class whileDemo01 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        do {
            sum = sum+i;
            i++;
        } while(i>100);
        {
            System.out.println("sum="+sum);
            System.out.println("i="+i);
        }
        System.out.println("最终结果："+sum);
    }
}

for循环

• 虽然所有循环结构都可以用 while 或者 do…while 表达，但是Java提供了另外一种语句 ——for循环，使一些循环结构变得更加简单。
• for循环语句是支持送代的一种通用结构，是最有效，最灵活的循环结构。
• for循环执行的次数是在执行前就确定的。
• 语法

for(初始化；布尔表达式；更新)｛
    //代码语句
   ｝

     - 最先执行初始化步骤，可以声明一种类型，但可初始化一个或者多个循环控制变量，可以是空句
      - 然后，检测布尔表达式的值，如果是true，循环体被执行，如果为false，循环终止，开始执行循环体后面的语句。
      - 执行一次循环后，更新循环控制变量（送代因子控制循环变量的增减）。
      - 再次检查布尔表达式，循环执行上面的过程。

1. 练习1：计算0到100之间的奇数和偶数的和
2. 练习2：用while或者for循环输出1-1000之间能被5整除的数，并且每行输出3个。
3. 练习3：打印九九乘法表

1

public class ForDemo01 {
    public static void main(String[] args) {
        int oddSum = 0;
        int evenSum = 0;
        for (int i = 0; i <=100; i++) {
            if (i%2!=0){
                oddSum=oddSum+i;
            }else {
                evenSum=evenSum+i; 
            }
        }
        System.out.println("偶数合计为："+oddSum);
        System.out.println("奇数合计为："+evenSum);
    }
}

2

public class ForDemo02 {
    public static void main(String[] args) {
        System.out.println("5的倍数：");
        for (int i = 1; i <=1000; i++) {
            if (i%5==0){
                System.out.print(i+" ");//可以（i+"\t"）
            }
            if (i%(5*3)==0){
                System.out.println();//可以print("\n")
            }
        }
    }
}

while

   public static void main(String[] args) {
       int i = 1;
       while (i<=100){
           if (i%5==0){
               System.out.print(i+" ");
           }
           if(i%15==0){
               System.out.println();
           }i++;
           }
       }
   }

3

public class ForDemo04 {
 public static void main(String[] args) {
     System.out.println("九九乘法表：");
     for (int j = 1; j < 10; j++) {
         for (int i = 1; i <= j; i++) {
             System.out.print(i + "*" + j + "=" + (i * j)+" ");
         }
         System.out.println();
     }
 }
}

增强for循环

• 这里我们先只是见一面，做个了解，之后数组我们重点使用。
• Java5 引入了一种主要用于数组或集合的增强型 for 循环。
• Java 增强 for 循环语法格式如下：

for(声明语句：表达式)
{
    //代码句子
}

• 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
• 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

    public static void main(String[] args) {
        int[] numbers = {10,20,30,40,50};//定义了一个数组
        for (int i = 0; i < 5; i++) {
            System.out.println(numbers[i]);
        }
        System.out.println("===============================");
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

break&continue

• break 在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强行退出循环，不执行循环中剩余的语句。（break语句也在switchi语句中使用）。

    public static void main(String[] args) {
        int i = 0 ;
        while (i<100){
            i++;
            System.out.println(i);
            if (i==30){
                break;
            }
            System.out.println("break："+i);//break强制结束，虽然程序还未到达条件（i<100），但是循环已结束。
        }
        System.out.println("程序结束！");//循环外的程序还可以执行
    }
}

• continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下次是否执行循环的判定。
• 关于 goto 关键字
  1. goto 关键字很早就在程序设计语言中出现，尽管 goto 仍是 Java 的一个保留字，但并未在语言中得到正式使用； Java没有 goto 。然而，在 break 和 continue 这两个关键字的身上，我们仍然能看出一些 goto 的影子—带标签的 break 和 continue。
  2. “标签”是指后面跟一个冒号的标识符，例如： label:
  3. 对 Java 来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一循环，由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

public static void main(String[] args) {
    outer: for (int i=101;i<150;i++){
        for(int j=2;j<i/2;j++){
           if (i%j==0){
               continue outer;//满足条件后回到 outer 记录位置从新运行。
          }
        }
        System.out.println(i);
    }
}

练习

打印三角形

        for (int i = 1; i <= 5; i++) {
                for (int j = 5; j >=i; j--) {
                    System.out.print(" ");
        }
                for (int j = 1; j <=i; j++){
                System.out.print("*");
            }
                for (int j = 1; j < i; j++){
                    System.out.print("*");
                }
                System.out.println();
    }
}