1. 变量

        数据类型  变量名=值

        数据类型：

                        1.基本数据类型：byte[1字节]，short[2字节]，int[4字节]，long[8字节]，

                                                    float[4字节]，double[8字节]，boolean[1字节]，char[2字节]        

                        2.引用数据类型：类        接口        枚举        数组

        变量名（命名规则）：

                        1.由字母   数字   下划线_     美元符号$ 组成

                        2.不能以数字开头

                        3.不能使用java的关键字

2.运算符

        1.算数运算符：+，-，*，/，%，++【前(先+1在运算)      后（先运算再加1）】，--

        2.关系运算符：>，<，>=，<=，==，！=  得到的结果一定是Boolean值

        3.逻辑运算符：连接多个关系运算符的。

                                 && 【这两个关系运算符得到的结构都是true才为true】

                                 ||    【两个关系运算符只要有一个为true，就是true】

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

                      例子：int a=2; int b =2; b * =a+1; b=b*(a+1) sout(b)

        5.位运算符【二进制】：&,|,^,>>（右移）,<<（左移）

        6.三目运算符：条件语句？表达式1：表达式2

3.控制语句

        1.if循环

                if(条件){ }

                if(条件){ }else{ }

                if(条件){ } if else(条件){}...........else{ }

        2.switch循环

                switch(表达式){

                case 值1:        break;

                case 值2:        break;

                case值3:        break;

                default:          break;

                } 

                注意：1.表达式中的类型：byte        short        char        int        String

                           2.default   找到不匹配的case时执行default的语句

                           3.break   执行完对应的case后，跳出switch语句。如果没有使用break则找到匹配的case后会把后面所有语句都执行。

        3.while循环

                        while(条件){   }   //条件是boolean的值

        4.do   while循环

                        do{ }while(条件)

        5.for循环

                        for(初始值;条件；变化)  {  }        //初始值只会被执行一次

4.数组

        数据类型[ ] 变量名=new 数据类型[长度];

        数据类型[ ] 变量名={值1,值2 ,值3 ,值4 };

        排序:冒泡排序       选择排序[擂台排序]

        冒泡排序：

public class Bubble {
    public static void main(String[] args) {
        //创建一个数组
        int[] arr={21,2,3,5,12,3,58};
        //开始排序
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr.length-1;j++){
                //判断第一个和第二个数
                if(arr[j]>arr[j+1]){
                    //如果第一个数大于第二数，将第一个数放到一边
                    int temp=arr[j];
                    //将第二个数移到第一个数的位置
                    arr[j]=arr[j+1];
                    //将第一个数在放入到第二个数的位置
                    arr[j+1]=temp;
                }
            }
        }
        //增强遍历
        for(int a:arr){
            System.out.println(a);
        }
    }
}

        选择排序：

public class Selection {
    public static void main(String[] args) {
        //创建数组
        int[] arr={23,1,53,56,35};
        //进行排序
        for(int i=0;i<arr.length;i++){
            for(int j=i+1;j<arr.length;j++){
                //第一个数和第二个数进行比较
                    if(arr[i]>arr[j]){
                        int temp=arr[i];
                        arr[i]=arr[j];
                        arr[j]=temp;
                 }
            }
        }

        for(int  a:arr){
            System.out.println(a);
        }
    }
}

JAVA面向对象

1.类和对象

        类：具有相同属性和行为的一组对象的集合。  抽象的概念

        对象：万事万物皆为对象。   具体存在的实物

2.如何定义类

public class 类名{
    //成员变量
    //成员方法
}
//如何根据类创建对象
	类名   对象名=new 类名();
//对象如何调用类中的成员
	对象名.成员变量;
	对象名.成员方法(实参)
		

3.三大特性 

        封装：把类中成员使用private进行封装，使外界无法之间调用。-----------安全

                   一般封装属性，并且生成getter和setter方法

        继承：一个子类继承父类中的成员   关键字：extends

public class 子类名 extends 父类名

        重写（override）和重载(overload)的区别：

                重载（overload）：在同一个类中，出现方法名相同，参数列表不同的方法，不考虑返回 类型。这些方法就是方法重载。

                重写(override)：在父类和子类之间，子类中出现和父类中方法名一样，参数列表一样。返回值类型。访问修饰符不能小于父类方法的访问修饰符。抛出的异常不能大于父类中。子类中出现的这种方法就是方法重写。

                访问修饰符：

                                private：同一个工程下都可以访问

                                protected：同包或者不同包下的子类访问

                                默认：同包访问

                                private：同类访问

4.多态

        一个对象具有多种形态。

        父类声明 对象名=new 子类对象(); //向上转型：对象名.方法():调用的是子类重写的方法

        子类声明 对象名=（子类）父类对象; //向下转型

5.抽象类和接口

        抽象类：只能被继承，因为他不能实例化对象。抽象类中有构造方法。抽象类中可以由非抽象方法。抽象类中的属性可以是普通属性也可以是静态属性。

        接口：可以被多个实现。没有构造方法。全是抽象方法[jdk8后出现了默认方法和静态方法]。都是静态常量。

异常处理        

        try{  }catch(异常类型 对象){  }

        throws 抛出异常.---------->throws加在方法参数的后面 ，谁调用该方法谁处理这异常

集合

        collection：

                LIst：有序，可重复

                        ArraryList：底层是数组：查询快，缺点：前提不是尾部元素，插入和删除慢

                        LinkedList：底层是链表。优点：插入和删除快

                Set：无序，不可重复

                        HashSet：底层是按照hash表执行。先按照hashcode表比对如果hash相同【hash冲突】，则按照equals方法比对。如果equals也相则视为同一个元素。

                        TreeSet：底层是树形结构        元素排好序。

                        LinkedHashSer：排好序，按照添加的顺序。

        Map:

                HaspMap：原理：map.put(key,value);map.get(key);数组+链表[超过8]+红黑树。

                TreeMap：TreeSet相似。