2.JAVA入门基础知识

数据类型：

java的数据类型分为两大类：基本类型和引用类型

基本类型：

整数类型：

byte 一个字节 -128-127
short 2个字节 32768-32767
int 4个字节很大
long 8个字节巨大用long的时候赋值要在数字后加 L

扩展：

public class HelloWorld {
    public static void main(String[] args) {
       int i=10; //10进制
       int i2=010; //八进制         八进制0开头
       int i3=0x10;  //十六进制      十六进制0x开头
       int i4=10_00001_23; //JDK7新特性，数字之间可以用下划线分割，且输出的时候不会被输出
    }
}

浮点类型：

float 4个字节用float的时候赋值要在数字后面加 F
double 8个字节

扩展：最后完全避免使用浮点数进行比较

字符类型：

char 2个字节只能发一个字符

String 定义字符串不是关键字来的，是类

扩展：所有的字符本质还是数字即ASCII编码

转义字符：

\t 多几个空格
\n 换行
....

boolean类型：

boolean xx= true

其值只有true和false两个

引用类型： 类、接口、数组

类型转换：

数字范围级别：低--------------------------------------------->高

byte,short,char --->int --->long--->float--->double

当高级别向低级别转换时，需要强制类型转换；低级别向高级别转换时，无需任何操作

数据类型按精度（容量）大小排序：

自动类型转换：

精度小的类型自动转为精度大的数据类型，这就是自动类型转换

自动类型转换细节：

有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大那种数据类型，然后再计算
当把精度（容量）大的数据类型赋值给精度（容量）小的数据类型，会报错；反正会进行自动类型转换
(byte、short)和char之间不会相互自动转换
byte、short、char 它们三者可以计算，在计算时首先转换为int类型
boolean不参与转换
表达式结果的类型自动提升为操作数中最大的类型

强制类型转换：

强制转换：（类型）变量名

注意：

不能对布尔值进行转换
不能把对象类型转换为不相干类型
在把高容量转换到低容量时，需要强制类型转换。此时会出现内存溢出或者精度问题
不同类型的数字相结合成为一个新的数字时，得出的结果按最高的级别来算，最低只能是int

public class HelloWorld {
    public static void main(String[] args) {
        int i=10_0000_0000;
        int b=20;
        long sum=i*b;    //结果是负数，原因是i*b之后还是int类型，然后溢出了
        long sum1=i*((long)b);    //结果是正数，先把一个数转化为long 结果i*b之后就算long
        System.out.println(sum);
    }
}

变量与常量：

变量分为类变量、实例变量、局部变量

public class HelloWorld {
    //类变量 static
    static double salary= 2000;

    //实例变量:从属于对象；若不进行初始化，则为默认值，整数0 浮点数0.0 布尔值false  除了基本类型其余都是NULL
    int a;
    //main方法
    public static void main(String[] args) {
        //局部变量：必须声明且初始化，有效范围只在方法內
        int i=10;   //局部

        //变量类型  变量名字 = 值  使用实例变量必须new
        HelloWorld text = new HelloWorld();
        System.out.println(text.a);

        //类变量 static  类变量可以直接用
        System.out.println(salary);
    }
    //其他方法
    public void  add(){

    }
}

常量：

格式：final 常量名 =值; 常量名一般用大写字符

public class HelloWorld {
    //修饰符，不存在先后顺序，所以可以改为final static
    static final double PI=3.14;
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范：

类成员变量：首字母小写和驼峰原则（除了第一个单词外，后面的单词首字母大写）myName
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：MyName
方法名：首字母小写和驼峰原则：myName()

运算符：

数字范围级别：低--------------------------------------------->高

byte,short,char --->int --->long--->float--->double

不同类型的数字相结合成为一个新的数字时，得出的结果按最高的级别来算，最低只能是int

关系运算符：返回值是true或false

public class HelloWorld {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        //字符串连接符 + 当出现字符串时，会把字符串后的内容转化为字符串，并进行连接
        System.out.println(""+a+b);  //结果1020
        System.out.println(a+b+"");  //结果30
    }
}

Scanner对象：

可以通过Scanner类获取用户的输入

Scanner的用法：

导包：import java.util.Scanner; （IDEA上new一下就自动导包了）
新建对象：Scanner s new Scanner(System.in); s是变量名，其他都不能改
使用对象：
- s.next(); 输入字符串，遇到空格结束 s.nextLine() 输入字符串，遇到回车结束
- s.nextInt(); 输入整数
- s.nextFloat(); 输入浮点数float类型
- s.nextDouble(); 输入浮点数double类型

在一个方法中new了一个scanner对象后，可以给不同的类型进行输入赋值

通过Scanner类的next()与nextLine()方法获取输入的内容，一般读取前需要使用hasNext()与hasNextLine()来判断是否含有相同类型的输入的数据。如hasNextInt() 判断输入的是否是整数

import java.util.Scanner;
//hasNext()的用法
public class doc {
    //输入多个数字，算总和和平均数。通过输入非数字来结束
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        double sum=0;
        int m=0;
        while(scanner.hasNextDouble()){   //当我输入到x时 x不是double类型 循环结束
            double x=scanner.nextDouble();
            m++;
            sum+=x;
        }
        System.out.println("和为："+sum);
        System.out.println("平均值："+(sum/m));
    }
}

next()与nextLine()的区别：

next()遇到空格就作为分隔符或结束符
nextLine()以Enter作为结束符可以获得空白

import java.util.Scanner;
public class doc {
    public static void main(String[] args) {
        Scanner s =new Scanner(System.in);
        System.out.println("使用next方式接收");
        //判断用户有没有输入字符串
        if(s.hasNext()){   //先判断用户输入的是什么内容
            //使用next接收
            String str=s.next();
            System.out.println("输入的内容："+str);  //输入Hello World 结果为Hello
        }
        //用完scanner最好关闭
        s.close();
    }
}

import java.util.Scanner;
public class doc {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        System.out.println("用nextline方式接收");
        if(s.hasNextLine()){   //先判断用户输入的是什么内容
             //使用nextLine接收
            String str=s.nextLine();
            System.out.println("输入的内容为："+str); //输入Hello World 结果为Hello World
        }
        s.close();
    }
}

选择结构：

单选择结构：

if(布尔表达式){ //true就执行

}

import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        String a=s.nextLine();
        //equals 字符串比较
        if(a.equals("Hello"))
            System.out.println(a);
        s.close();
    }
}

双选择结构：

if(布尔表达式){ //ture 就执行

}else{ //false就执行

}

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

多选择结构：

if(布尔表达式1){ //true就执行

}else if(布尔表达式2){ //true就执行

}else if(布尔表达式3){ //true就执行

}else{ //上面3个表达式都false就执行

}

import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int score=s.nextInt();
        if(score==100){
            System.out.println("满分");
        }else if(score<100&&score>=90){
            System.out.println("A");
        }else if(score<90&&score>=80){
            System.out.println("B");
        }else{
            System.out.println("C");
        }
        s.close();
    }
}

switch多选择结构：

switch(表达式){

case 常量：语句；break；

case 常量：语句；break;

default: 语句；break;

}

JDK7的新特性，表达式的结果可以是字符串！

public class Demo {
    public static void main(String[] args) {
        char grade='C';
        switch (grade){
            case 'A':
                System.out.println("A");
                break;    //若不写break，会发生case穿透
            case 'B':   //这个case无break，若执行了，还会穿透到下面的case C
                System.out.println("B");
            case 'C':
                System.out.println("C");
            default:
                System.out.println("aaaa");
                
        }
    }
}

循环结构：

while循环：

while(布尔表达式){

//内容

}

do....while循环：

do{

}while(布尔表达式);

do....while() 至少执行一次

for循环：

for(初始化；布尔表达式；更新){ //初始化不能只写一个变量，必须带上赋值

}

输入循环次数加上 .for 回车自动生成for循环

public class Demo {
    public static void main(String[] args) {
        int a=1;
        int sum=0;
        for(a=1;a<=100;a++){     //写成for(a;a<=100;a++) 就报错
            sum+=a;
        }
        System.out.println(sum);
    }
}

练练手：

public class Demo {
    public static void main(String[] args) {
        //输出1-1000之间能被5整除的数，每行输出3个
        for (int i = 1; i <= 1000; i++) {
            if(i%5==0){
                System.out.print(i+"\t");   //print输出后不换行，println输出自带换行
            }
            if(i%(5*3)==0){      //每行输出3个
                System.out.println();   //换行
                //System.out.print("\n");   换行
            }
        }
    }
}

增强for循环：

增强for循环主要用于数组或集合的循环

for(声明语句：表达式){

//代码句子

}

public class Demo {
    public static void main(String[] args) {
        int[] numbers={10,20,30,40,50}; //定义数组
        //遍历数组的元素
        for (int x:numbers){    //numbers数组的每一项遍历出来赋值给了x
            System.out.println(x);
        }
        System.out.println("==============");
        //等同于上面的代码
        for(int i=0;i<5;i++){
            System.out.println(numbers[i]);
        }
    }
}

break与continue：

break：用于结束循环,不执行了

continue：用于结束这一次循环，进行下一次循环

数组：

一维数组的介绍

数组是相同类型的数据的有序集合，每一个数据成为一个数组元素，每一个数组元素可以通过一个下标来访问

数组是引用类型。它的元素相当于类的实例变量

特点：

数组的长度是固定的。一旦被创建，大小不可以改变
其元素必须是相同类型
数组中的元素可以是任何类型数据，包括基本类型和引用类型
数据变量是引用类型，数组也可用看成是对象，数组中的每个元素相当于该对象的成员变量
数组本身是对象，数组对象本身是在堆中的

数组的声明创建：

先声明数组变量，然后通过new来创建数组，数字的下标从0开始

public class Demo01 {
    public static void main(String[] args) {
        //变量类型   变量名字 = 变量的值;
        int[] nums1;   //声明了一个数组，首选，但是还没分配空间; 可写成int nums2[];  不推荐
        nums1 = new int[10];   //分配空间，创建一个可以放10个int类型数据的数组
        int[] nums2=new int[10]; //这一行把定义和new结合，等同于上面2行
        nums2[0] = 1;  //给数组第0个数组赋值
    }
}

数组的声明：

public class Demo02 {
    public static void main(String[] args) {
        //静态初始化：创建+赋值    不用写new,但是初始化有多少个值，就是数组的长度
        int[] a={1,2,3,4,5,6,7,8};

        //动态初始化： 创建后，数组元素默认都为0
        int[] b=new int[10];
    }
}

数组的赋值和遍历：

获取数组的长度用arrays.length （arrays数组变量名）

public class Demo01 {
    public static void main(String[] args) {
        int[] num=new int[10];
        for (int i = 0; i < 10; i++) {
            num[i]=i;
        }
        //遍历输出数组
        for (int i = 0; i < num.length; i++) {   //num.length 是数组的长度
            System.out.print(num[i]+" ");
        }
        System.out.println();
        //增强型for输出数组    没有下标
		for (int array : arrays) {      //输入数组名.for 快速生成
            System.out.println(array);
        }
    }
}

数组作为方法的参数

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
        printArrays(arrays);   //数组作为参数
    }
    //打印数组   数组作为方法的参数
    public static void printArrays(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }

}

=数组作为返回值

public class Demo04 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};
        int[] reverse = reverse(arrays);  
    }
    //反转数组   数组作为返回值
    public static int[] reverse(int[] arrays){    //定义的方法类型必须也是数组
        int[] result =new int[arrays.length];
        for(int i=0,j= result.length-1;i< arrays.length;i++,j--){
            result[j]=arrays[i];
        }
        return result;   //返回一个数组
    }

}

二维数组的介绍

二维数组就是一个数组中存放了其他数组

当初始化一个二维数组时，若某行某列没有赋值，则默认不存在，遍历的时候并不会输出

public class Demo05 {
    public static void main(String[] args) {
        //定义了一个array[4][2]
        int[][] array={{1,2},{2,3},{3,4},{4,5}};
        System.out.println(array.length);    //输出二维数组的长度是4
        System.out.println(array[0].length);  //输出二维数组中第一个数组的长度 结果是2
       //二维数组的打印
        for (int i = 0; i < array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }
}

二维数组的增强型for遍历：

快捷操作：array1.for 就自动生成 for (int[] ints : array1) 然后ints.for就自动生成for (int anInt : ints)

public class Demo07 {
    public static void main(String[] args) {
        int[][] array1 =new int[11][11];  //二维数组的定义
        for (int[] ints : array1) {    //相当于把array1中的每一个数组赋给了ints
            for (int anInt : ints) {  //把ints数组中的值赋给了anInt
                System.out.print(anInt+" ");
            }
            System.out.println();
        }
    }
}

Arrays类

Arrays类包含了多种对数组进行特定操作的方法

使用的时候就 Arrays . 方法(数组名) 就可以直接使用

使用Arrays需时会自动导包 import java.util.Arrays;

Arrays类的方法可以查看JDK帮助文档

常用的有：

toString 打印数组
sort 升序排序数组
equals 比较数组中的元素是否相等
binarySearch 对排序好的数组进行二分查找

import java.util.Arrays;

public class Demo05 {
    public static void main(String[] args) {
        int[] a={1,2,3,456,12,4};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}