一、Java基础复习①

java：一门纯面向对象的编程语言
特点：
1、一次编写，随处运行（java写好程序编译成class文件后，这个class文件是在java平台上运行的，所以你就不用管它是windows还是linux）
2、垃圾回收机制

对象的生命周期：
初始化——实例化——垃圾收集——对象终结——卸载。

JVM：java虚拟机，java代码就是运行在JVM上。
.class文件：字节码文件，java程序执行的就是这个文件，JVM就是运行这个文件
.java文件：java源文件，正常编写的java代码。
JRE：java运行时环境。
JDK：java开发工具包。

一个简单的HelloWorld小程序

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("Hello world!");
	}
}

运行结果：

Hello world!

易错方法：
1、next()：获取用户输入的字符串，返回String类型，并且是一个阻塞方法，会阻塞主方 法的运行；有空格出现时，空格后面的无法获取
2、nextLine()：获取一整行的字符信息，返回值为String。遇到换行符即停止

java中数据类型：
引用数据类型：除了基本数据类型之外的都是引用数据类型
基本数据类型：
boolean：代表逻辑上的成立与不成立
byte：字节型整数，占一个字节
short：短整型，占2字节
int：整形，占4字节，整形中默认是int
long：长整型，占8字节，在数字后需要添加l，例如long a=100l;
double：浮点型，占8字节，浮点数中默认是double
float：浮点型，占4字节，在数字后需要添加f，例如float a = 10.0f;
char：字符型，占2字节，可以代表一个汉字，数字，一个英文字母，一个字符。使用‘’包围起来，例如‘A’
精度由低到高：byte|char|short->int->long->float->double
byte|char|short这三者之间不会类型转换

为什么要有包装器类型？
基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型（如我们在使用集合类型Collection时就一定要使用包装类型而非基本类型），它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作

类型转换的问题：
1.自动类型转换：
当低精度的数据赋值给高精度的变量的时候会发生自动类型转换。或者是低精度与高精度在一起进行运算的时候也会进行自动类型转换。例如int a ='A' ;
2.强制类型转换：
当高精度的数据赋值给低精度的变量的时候，如果不想编译出错，需要强制类型转换。特意将某一个类型进行转换。例如 char a = (char)65;

变量的命名规则:
1.由于java是强类型的编程语言，所有的变量必须指定类型。
2.变量必须声明才能使用。
3.变量必须赋值之后才能使用。
4.变量名称只能包含英文字母、数字、下划线、美元符，不能包含其他字符。
5.变量名称不能使用数字开头。
6.变量名称不能与java中的53个关键字同名
7.变量名称在同一个作用域之内必须保证唯一
8.变量名称要是用清晰词汇命名，使用驼峰式命名原则。

++：自增，就相当于对变量本身执行+1的操作。
前自增：将++写在表达式或者是变量的前面,表达式与变量都发生变化（都执行+1的操作）
后自增：将++写在表达式或者是变量的后面,表达式不变，变量本身发生变化（执行+1的操作）

char c = 'c';
        c+=1;
        c=c+1;//报错，类型转换异常
        //+=”是java中的一个运算符，而不是两个，所以在运算时 会进行自动类型转换

–：自减，就相当于对变量本身执行-1的操作。
前自减：将–写在表达式或者是变量的前面,表达式与变量都发生变化（都执行-1的操作）
后自减：将–写在表达式或者是变量的后面,表达式不变，变量本身发生变化（执行-1的操作）

&&:逻辑与也称作是短路与
作用在两个布尔类型的表达式之间时，如果有一个表达式返回结果为false，则整体的返回结果就是false，如果两个表达式返回结果都是true，则整体的结果才是true。有假则为假，全真才是真。
如果两个表达式，前面的表达式返回结果为false则后面的表达式不再执行。

||：逻辑或也称作短路或
作用在两个布尔类型的表达式之间时，如果有一个表达式返回结果为true，则整体的返回结果就是true，如果两个表达式返回结果都是false，则整体的结果才是false。有真则为真，全假才是假
如果两个表达式，前面的表达式返回结果为true则后面的表达式不再执行。

&:按位与
1.如果作用在两个数值之间，代表按位与运算，全1才是1
2.如果作用在两个返回布尔类型的表达式之间，作用与逻辑与一致，但是不短路

|：逻辑或
1.如果作用在两个数值之间，代表按位或运算，有1则为1，全0才是0
2.如果作用在两个返回布尔类型的表达式之间，作用与逻辑与一致，但是不短路

Math类：是java.lang包中的一个类。给我们提供了进行复杂运算的方法，并且这些方法都是静态方法（静态方法可以直接通过类名.方法名调用，不用创建对象）
11、Math.abs(a);求a的绝对值
2、Math.max(a,b);求a与b之间的最大值，返回结果如果是两个整数求最大值得到的整数，如果两个小数或者一个整数一个小数等到的都是小数。
3、Math.min(a,b);求a与b之间的最小值，返回结果如果是两个整数求最大值得到的整数，如果两个小数或者一个整数一个小数等到的都是double类型的值。
4、Math.pow(a,b):求a的b次方，得到结果是double类型的值
5、Math.sqrt(a):求a的平方根，得到结果是double类型的值
6、Math.random():求随机数，随机范围是0.0-0.9999999999999999
如果想随机n-m之间的小数
Math.random()*(m-n)+n

在循环语句中的Switch语句
Switch语句本身属于贯通式语句。为了不让Switch语句贯通，我们可以使用break关键字，break关键字的作用是跳出switch语句。

在循环语句中，
break:终止当前这一层的循环
continue:中断当前这一次循环，循环从下一次继续执行

包装器类型：

byte Byte
short Short
int Integer
long Long
float Float
double Double
boolean Boolean
char Character

装箱：
由基本数据类型转变为包装器类型的过程叫装箱。
1.手动装箱：

int i=10;
Integer iter = new Integer(i);

2.在JDK1.5之后出现了自动装箱

int i=10;
Integer iter = i;

拆箱:
由包装器类型转变为基本数据类型的过程叫做拆箱
1.手动拆箱：

Integer iter = new Integer(10);
int num   = iter.intValue();

2.自动拆箱

Integer iter = new Integer(10);
int num = iter;

一维数组的几种声明方式
1.静态声明方式1
类型[] 数组对象名称 = {数据1,数据2,…,数据n};
2.数组的静态声明2
语法：
类型[] 数组对象名称 = new 类型[]{数据1,数据2,…,数据n};
3.数组的动态声明：
类型[] 数组对象名称 = new 类型[长度];

二维数组的声明方式
1.静态声明方式1
类型[][] 数组对象名称 = {{数据1,数据2,…数据n},{数据1,数据2,…,数据n},…,{数据1,数据2,…,数据n}};
2.静态声明方式2
类型[][] 数组对象名称 = new 类型[][]{{数据1,数据2,…数据n},{数据1,数据2,…,数据n},…,{数据1,数据2,…,数据n}};
3.动态声明:
类型[][] 数字组对象名称 = new 类型[长度1][长度2];
其中：长度1代表二维数组的长度，是必须写的。
长度2代表二维数组中每一个一维数组的长度，是可以不写的。

冒泡排序：

public class Test {
    public static void main(String[] args) {
        int a[] ={1,2,5,6,8,7,4,3,10,9};
        for (int i=0;i<a.length-1;i++){
            for (int j=a.length-1;j>i;j--){
                if (a[j]<a[j-1]){
                    int temp =a[j];
                    a[j]=a[j-1];
                    a[j-1]=temp;
                }
            }
        }
        for (int temp:a)
            System.out.print(temp+" ");
    }
}