java基础语法

注释

一般情况下都是用/** */ ，这是阿里公约用的。

/**
*
*/

每句后面用的是//

单行注释 多行注释 文档注释

不要进行嵌套

关键字

字母全部小写

关键字都有特殊的颜色标记

class

用于（创建）一个类是java最基本的组成单元，

定义一个类后面跟着类名

字面量

字面量类型	说明	举例	备注
整数类型	不带小数点的数字		int
小数类型	带小数点的数字
字符串类型	用双引号括出来的内容
字符类型	用单引号括出来的，内容只能有一个
空类型	空值	null	不能直接打印null

制表符

\t 让数据对齐

变量

在程序中有可能发生改变的量，也可以称为存储数据的小空间。

用变量存储，如果之后想要改变可以直接改变量

变量的定义格式

数据类型 变量名 = 数据值

变量名为空间起的名字 数据值为存在空间里面的数值

数据类型：为空间中存储的数据，加入类型限制的 例如整数小数之类的

public  class  xxx{
  //主入口
    public static void main(String[]agrs){
        //定义变量
        //数据类型  变量名 = 数据值
    int a = 10;
    System.out,println(a);

使用方式

输出打印

int a = 10;
System.out,println(a);

参与计算

int a = 10;
int b = 20；
System.out,println(a + b);

修改记录的值

int a = 10;
System.out,println(a);
a=20；
System.out.println(a);

注意事项

变量的名字不能重复

只能存一个值

一条语句中可以定义多个变量

int d =100,e = 200,f = 300

变量在使用之前一定要进行赋值

计算机的存储规则

在计算机中，任意数据都是以二进制的形式来存储

不同进制在代码中的表现形式

二进制：只有0和1组成，代码中以0b开头

十进制：又0-9组成，前面不加任何前缀

八进制：由0-7组成，代码中以0开头

十六进制：由0-9还有a-f组成，代码中以0x开头

在Mac上使用计算器的操作方法

打开应用程序里面的计算器，点击最上方的显示会出来程序员计算器使用

ASCII表

Unicode编码

国际标准字符集，他将世界各种语言的每个字符定义一个唯一的编码，以满足跨语言，跨平台的文本信息转换。

数据类型

基本数据类型

其中 int 和double是默认的

如果定义long类型的

long n = 999999L

如果定义long类型的变量，在数据值的后面需要加一个L作为后缀，小写大写都可以

float也是同理

整数小数取值范围大小关系：

double>float>long>int>short>byte

标识符

说白了就是设置的名字，自己起名字

命名规则

由数字，字母，下划线和$组成

不能以数字开头

不能是关键字

区分大小写

小驼峰命名法：方法，变量

标识符是一个单词的时候，全部小写 eg：name

标识符由多个单词组成时，第一个首字母小写，其余首字母大写，first Name

大驼峰命名法：类名

标识符是一个单词的时候，首字母大写

标识符由多个多个单词组成的时候，每个单词的首字母大写

最主要是要见名知意

键盘录入

Scanner

已经写好的类

创建类的方法

步骤一：导包--- Scanner这个类在哪

import java.util.Scanner;

步骤二：创建对象---表示我要开始用这个类

Scanner sc = new Scanner(System.in);
sc是变量名可以进行改变

步骤三：接受数据---开始干活

int i = sc.nextInt();
i是变量名可以改变

scanner是要写在int i=10 前面

运算符

运算符和表达式

运算符是对字面量或者变量进行操作的符号

表达式是：用运算符把字面量或者变量连接起来，符合java语法的式子就可以称为表达式

eg：int c=a+b ➕是运算符 整个式子是表达式

算术运算符

int a=8,b=3,c;
//c等于11
c=a+b;
//c等于5
c=a-b;
//c等于24
c=a*b;
//c等于2（发生的是整除）
c=a/b;
//c等于2（取余）
c=a%b;

在代码中，如果有小数参与计算，结果有可能是不精确的

整数参与计算只有整数 ，如果想要小数必须是10.0/3.

% 表示取余

应用场景

A能否可以比B整除 A%B

可以判断A是否为偶数

+的应用场景

数字相加

数字进行运算的时候，需要转成一样的类型才能进行运算

隐式转换

把一个取值范围小的数据转乘取值范围大的数据 代码自动转

byte short char 三种类型的数据在运算的时候。都会直接先提升为int在进行运算

byte a=10；
byte b=20；
int c=a+b；

强制转换

把取值范围大的数据，赋值给取值范围小的变量需要强制转换

格式：目标数据类型 变量名=（目标数据类型）（被强制转的数据）

字符串的+操作

当➕的操作出现字符串的时候会将前后的数据进行拼接，并产生一个新的字符串

eg：“123”+123； 123123

连续进行+操作时，从左到右逐个进行

eg：1+99+“啦啦啦” 100啦啦啦

字符相加

char c=‘a’
会转成ascii码97
两个字符相加要转成ascii码表在进行计算

自增自减运算符

++和--无论放在变量前面还是后面单独成一行都是一样的

int a=10;

int b=a++; 先用后加

int a=10;

int b=a++; 先加后用

赋值运算符

说白了就是算术运算符之后加个=

将左边和右边相加 += （以此类推 剩下的都是一样的）

int a=10;
int b=20;
a +=b
等同于 a = a+b

底层都隐藏了强制类型转换

关系运算符（比较运算符）

true 为0 false为1

逻辑运算符

使用场景

用户名和密码

短路逻辑运算符

在上述表里

运行结果跟普通的是一样的 基本用的是这个，效率比较高

短路效果

如果左边的表达式能确定最终的结果，那么右边就不会参与运行了

如果是单个的 就都要进行参与

三元表达式

int c=a>b?a:b;

关系表达式？表达式1:表达式2；

关系表达式--boolean类型

10>1？表达式1:表达式2

10>1？===true==执行表达式1

10>20？===false===执行表达式2

Scanner使用基本步骤

1，导包 import java.util.Scanner;

导包的动作必须出现在定义类的上面

2，创建对象

Scanner sc=new Scanner（System.in）;

3,接受数据

int i=sc.nextInt();

i是为变量名称可以发生变化

//创建一个打印机
Scanner sc=new Scanner（System.in);
System.out.println("请您输入一个数值类型的数据“）；
//接受用户在控制台中输入int类型
int i=sc.nextIn();
System.out,println("您输入的数值类型值为："+i);

流程控制语句

1，顺序结构

基本的流程控制，按照先后次序依次进行

sout（“开始”）；

sout（“语句”）；

sout（“结束”）；

2，分支结构

判断语句1

if写法

格式：

if（关系表达式）{

语句题；

}

判断关系表达式看其结果是true还是false

如果是true执行语句题，如果是false就不执行语句体

if 写法2

if（关系表达式）{

语句体1；

else{

}

switch语句

switch（表达式）{

case 值1:

语句体1；

break；

case 值2:

语句体2；

break；

。。。。。。。

default：

语句体n+1；

break；

}

格式说明：

1，表达式取值为byte，short，int，char，jdk5以后是meun，jdk7以后是string；

2，case：后面跟的是要和表达式进行比较的值

3，语句体：可以是一条或者多条语句

4，break：表示中断，结束的意思，可以控制switch语句的结束

5，default：当所有的值都和表达式不匹配的时候，就可以执行default控制的语句，其实他就相当于if语句的else

执行流程：

1，首先计算出表达式

2，其次和case依次比较一旦有对应的值，就会执行相应的语句，在执行的过程中遇到break就会结束。

3，最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉

循环语句内容

循环语句1-for

循环结构的组成：

初始化语句：勇于表达循环开启时的起始状态，简单说就是循环开始时候什么样

条件判断语句：用于循环反复执行的条件，简单说就是判断循环是否能一直执行下去

循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情

条件控制语句：用于表示循环执行中的每次变化的内容，简单说就是控制循环是否能执行下去

循环结构对应的语法：

初始化语句：这里可以是一条语句或多条语句。这些语句可以完成一些初始化操作

条件判断语句：这里是用一个结果值为boolean类型的表达式，这个表达式表达式能决定是否执行循环体。例如a<3

循环体语句：这里可以是任意语句。这些语句将反复执行

条件控制语句：这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果，常见的i++，i-这样的操作。

for循环语句格式：

for （初始化语句；条件判断语句；条件控制语句）

{

循环体语句；

}

执行流程：

1，执行初始化语句

2，执行条件判断语句，看其结果是true还是false

如果是false,循环结束

如果是true，继续执行

3，执行循环体语句

4，执行条件控制语句

5，回到2过程继续

public static void main(String[] args) {
        System.out.println("控制输入我是");
        for (int i=0;i<5;i++){
            //1，初始化语句int i=0；
            //2，条件判断句i（0）<5 true
            //3，输出控制输入我是
            //4，条件控制语句 控制循环是否可以继续执行i+1
            //5，条件判断语句i（1）<5
            //6.输出控制输入我是
            //7。条件控制语句i（1）+1
            //条件判断语句i++5 i（5）<5 false 循环就结束了
            System.out.println("控制台输入");
        }
    }

打印出1-100之间的质数

public static void main(String[] args) {
        a:for (int i = 2; i < 100; i++) {
            for (int j = 2; j < i; j++) {
                if(i % j == 0){
                    continue a;
                }
            }
            System.out.println(i);
        }
    }

while循环语句

基本格式：

while（判断条件语句）{

循环体语句

}

完整格式：

初始化语句：

while（判断条件语句）{

循环体语句；

控制条件语句；

}

1，执行初始化语句

2，执行条件判断语句，看其结果是true还是false。

如果是false,循环结束

如果是true继续执行

3，执行循环体语句

4，执行条件控制语句

5，返回2继续执行

int j=1；//初始化语句
while（j<=5）{
sout（"输出内容"）
j++//控制条件语句
}
条件控制语句就是看当前循不循环

do while

do while语句

基本格式：

do{

循环体语句

}while（判断条件语句）；

初始化语句；

do{

循环体语句；

条件控制语句；

}while(条件判断语句);

执行流程：

1，执行初始化语句

2，执行循环体语句

3，执行条件控制语句

4，执行条件判断语句，看其结果是true还是false

如果是false，循环结束

如果是true，继续执行

5，回到2继续

int j=1；

do{

sout("输出语句")；

j++；

}while（j<=5）；

跳转控制语句

break：跳出循环，结束循环

continue：跳过本次循环，继续下次循环

注意：continue只能在循环中进行使用

public class Main {

    public static void main(String[] args) {
        //结束本次循环
        for(int i=1;i<=10;i++){
            if (i%2==0){
                continue;//结束本次循环
                break;//结束整次循环
            }
            System.out.println("i："+i);

        }
}

Random 随机数

作用：用于产生一个随机数

1，导包

import java.util.Random;

2，创建对象

Random r=new Random（）；

3，获取随机数

int number=r.nextInt();//获取数据的范围：【0，10）

数组

数组概述：一次性声明大量的用语存储数据的变量；

这些存储的数据通常都是相同类型数据

定义格式：数据类型[]变量名

int[]arr；

含义是定义了一个int类型的数组，数组名是arr

数组名变量的访问方式：数组名

数组内部保存的数据的访问方式：数组【索引】//编号从0开始

索引：索引是数组中数组的编号方式，作用就是用语访问数组中的数据，数组名【索引】等同于变量名，是一种特殊的变量名；索引从0开始是连续的

一旦初始化完成，其长度就确定了，并且其长度不可更改

数组元素的调用

通过角标的方式，获取数组的元素

角标的范围从0开始，到数组的长度-1结束

sout（price【1】）；

不再范围内的都是越界

浮点型数组元素的默认初始化值为0.0

double[] arr4 =new double[5];

sout(arr3[0]);

字符型数组默认元素的初始化值：0

boolean 型数组元素的默认初始化值：false

引用数据类型数组元素的默认初始化值：null

数组内存分配

System.out.println(arr[0]);//数组内存地址

数组静态初始化

静态初始化：初始化时制定每个数组元素的初始值，由系统决定数组长度

格式：数组类型[]数组名={元素1，元素2，元素3};

int[] arr={1,2,3};

public static void main(String[] args) {
        //静态初始化数组
        int[] arr=new int[]{2,3,4};
        int[] arr1={2,3,4};//简化方案
    }

数组获取最大值

定义一个变量，用于保存最大值（或者最小值）

int max;

取出数组中第一个数据作为变量的初始值

int max = arr[0];

数组中剩余逐个元素比较

for(in i=1;x<arr.length;i++){
       if(arr[i]>max){
            max=arr[i]
            }

public static void main(String[] args) {
        //1,定义一个数组存放身高
        int[] arr={151,150,170,162,131,168,126};
        //临时保存得最大值
        int max = arr[0];//临时最大值151  索引是0
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]>max){
                //修改临时保存的max值
                max=arr[i];
            }
        }
        System.out.println("数组中最大的值："+max);
    }