第一天：
1、java 的发展史
2009年jdk7 2014年jdk8 2017年jdk9
二进制和10进制转换： 除法，计算机中  2的n次方相加    127=64 + 32+16+8+4+2+1 =1111111
windows dos命令
cd 进入某个文件夹
盘符： 进入某个盘符
dir  查看文件夹中的文件
cls  清屏
javac 文件名.java    把.java后缀的文件编译成.class文件
java 文件名  运行.class文件
2、二进制
12  变为二进制： 1100   我们可以用计算机中的程序员的计算机可以转换
3、java开发环境的搭建
在windows环境变量
JAVA_HOME=D:\Program Files\Java\jdk-9.0.1  
Path =%JAVA_HOME%\bin
jdk和jre jvm  
注意事项：        1、一般我们配置JAVA_HOME的时候路径不要有中文名称  
                        2、一般情况下配置环境变量的时候不要有空格存在
                        3、原因，因为有空格、中文名称 在编译的时候会出现乱码现象
4、编写HelloWorld程序
        格式：
                //创建一个类 类名和文件名要保持一致
                public class HelloWorld{
                        //main方法  程序的入口，万年不变
                        public static void main(String[] args){
                                //输出一句话
                                System.out.println("Hello,World !!!");
                               
                        }
                }
5、常量和变量
                关键字: 就是java中具有特殊含义的单词，一般Notepad++中会变色单词，一般都是小写
                标识符：就是程序中我们自己定义的单词内容;如变量名，方法名，类名....，
                                硬性要求：只能用大小写字母，数字，$,_
                                                        不能以数字开头，不能是关键字
                                软性要求：        驼峰命名法，
                                                        如果有多个单词，首字母要大写，这个大驼峰命名法，适用于类名...
                                                        如果有多个单词，首字母要大写，第一个单词首字母小写，这个小驼峰命名法，适用于方法名...
                                                        变量名全部小写
                                               
                                                       
                常量：字符串常量 ""，整型常量 ，浮点性常量 小数，字符常量 ''，布尔常量
                变量：数据类型  标识符 ;创建一个变量，变量的申明
                                标识符=值;赋值
                                数据类型 标识符 = 值;   
                数据类型：基本数据类型
                        4类8中
                        整性    byte short int long L
                        浮点型  float F double
                        字符    char
                        布尔    boolean
                                引用数据类型 String
                               
第二天：
基本数据类型中{
        自动类型转换（隐式）
                从小到大  byte -->short --> char--> int--> long--> float--> double
                基本数据类型
                整数  byte short int long
                浮点数 float double
                字符 char
                布尔 boolean
        强制类型转换（显示）
                从大到小
                格式： 取值范围小的数据类型 取值范围小的变量名 = （取值范围小的数据类型）取值范围大的变量名;
                *注意          容易方式精度丢失，数据丢失
                                byte/short/char 都可以进行运算 例如+
                                byte/short/char 在运算的时候转换为int 在进行计算
                                boolean 不参与数据类型转换
                               
}
ASCII码表
0：47
A：65
a：97

运算符
1、算术运算符
        *+: 加法;         1、数值来说：加法计算
                                2、对应字符(char)类型 先把字符类型转换为int类型再进行加法计算  ASCII Unicode
                                3、对于字符串String   表示拼接
        -: 减法;
        *: 乘法;
        /: 除法;如果我用整数接收： 用的是我们小学一年级除法  要的是值 不要余数 如果用浮点数接收：获得值也是浮点数
        %: 取模(取余数);这个只能用整数接收：用的是我们小学一年级除法  要的是余数 不要值
        *注意
                如果运算有不同类型参与  那么结果一定数据大的那种接收，否则用强制类型转换接收
        ++:        表示自增1
                1、自己玩 int a =10; a++;  --> a =a+1;   a++ 和++a 没有区别
                2、和别人玩          int a =10; int b =a++; b=10 ,先赋值后加加
                                                int c =10; int d=++c; d=11 ,先加加后赋值  
        --: 表示自减1
                1、自己玩 int a =10; a++;  --> a =a+1;   a-- 和--a 没有区别
                2、和别人玩           int a =10; System.out.println(a--); 10 先输出后减键
                                                int b =10; System.out.println(--b); 9  先减减后输出
        *注意
                变量才能使用++和-- 常量不能使用
2、赋值运算符
        =  : int a =10;
        += : int b=10;  b+=3; -->  b=b+3; -->13
        -= : int c =20; c-=3; -->  c=c-3; -->17
        *= : int d =40; d*=3; -->  d=d*3; --> 120
        /= : int e =50; e/=3; -->  e=e/3; --> 16
        %= : int f =10; f%=3; -->  f=f%3; --> 1
        *注意
                只有变量才能使用赋值运算符，常量不能使用
                符合赋值运算符中隐藏着一个强制类型转换
3、比较运算符
        ==        : 两边相等为 true
        !=        : 两边不想等为 false
        >        : 左边大于右边 为true   左边小于等于右边 为false
        <        : 右边大于左边 为true        右边小于等于左边 为false
        >=        : 左边大于等于右边 为true 左边小于右边 为false
        <=        :右边大于等于左边 为true 右边小于左边 为false
        *注意：
                比较运算符结果一定是boolean值    不是true就是false
                比较运算符不能连载写： 比如我们数学中的【1<2<3】 在java中这是错误的写法
4、逻辑运算符
        &&        : 并且           两边为true        为true             短路&  一边为false 另一边就不执行了
        ||        : 或/或者        一边为true        为true                短路|  一边为true  另一部就不执行了
        !        : 非                把true变成false  把false变成true
        *注意：
                逻辑运算符只能用于boolean
                && || 需要左右两边各一个boolean值  !只有唯一一个boolean值
                && || 两种运算符 有多个条件  可以连续写
5、三元运算符
        格式: 数据类型 变量名 = 条件判断  ？ 表达式1:表达式2
                表达式为true 变量的值为结果1
                表示式为false 变量的值为结果2
        *注意
                表达式1 和 表达式2 必须同时符合左边数据类型的变量
                三元运算符的结果必须被使用
方法：
        好处：是代码更加简洁
        就是把一段【功能】抽取出来，放到一个大括号中，形成一个【单独的功能】
        格式：public static void 方法名(){}
        调用：方法名() 放到main方法中
        *注意
        方法的定义先后顺序无所谓
        方法的定义不能嵌套
        方法的定义好了，不会被执行 如果想用，我们一定要调用
jshell
        cmd 当中 jshell
       
第三天：
流程控制语句
        1、概念：在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说，程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。
        2、顺序流程：代码的从上到下一一执行的
        3、判断语句
                if
                格式：
                        if(布尔表达式){
                                语句体;
                        }
                if else
                格式：
                        if(布尔表达式){
                                语句体;
                        }else{
                                语句体;
                        }
                if else if...else
                格式:
                        if(布尔表达式){
                                语句体;
                        }else if(布尔表达式){
                                语句体;
                        }....else{
                                语句体
                        }
                switch case break;... default break;
                格式：
                        switch(表达式) 表达式:byte short char String enum(枚举)
                                case 常量值1:
                                        语句体;
                                        break;
                                case 常量值2:
                                        语句体;
                                        break;
                                default:
                                        语句体;
                                        break;
        4、循环语句
                概念：循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环
                4要素
                        初始化语句;
                        条件判断语句;
                        语句体;
                        步进语句;
                for
                格式：
                        for(初始化语句;条件判断语句;步进语句){
                                语句体;
                        }
                while
                格式：
                        初始化语句;
                        while(条件判断语句){
                                语句体;
                                步进语句;
                        }
                do while
                格式：
                        初始化语句;
                        do{
                                语句体;       
                                步进语句;
                        }while(条件判断语句);
                区别：
                        for循环和while循环可能不会执行一次，但是do...while循环一定会执行一次
                        for循环小括号中的变量只能在for循环中使用；但是while和do...while变量本来在循环外，所有在循环外也可以使用
                        建议：在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while
        死循环：也就是循环中的条件永远为true，死循环的是永不结束的循环。
                1.编写代码错误
                2.有意进行死循环
        嵌套循环：是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数
                格式
                        for(初始化语句;条件判断语句;步进语句){
                                for(初始化语句;条件判断语句;步进语句){
                                        语句体;
                                }
                        }
                       
第四天：
项目结构：
        idea:  最流行的结构体系
                项目名称(项目目录)
                        模块 一个项目下面可以有多个模块
                                包 一个模块下面可以有多个包
                                        类 一个包项目可以有多个类       
                项目名称
                        包 一个项目下面可以有多个包
                                类 一个包项目可以有多个类       

方法：
        概念：把一段功能抽取出来，单独放到一对大括号中，形成一个单独的功能
        格式：
                修饰符 返回值类型 方法名(参数列表){
                        方法体;
                        return 结果;
                }
                修饰符：public static
                返回值类型:  表示方法运行结果类型，最后给调佣者，注意：如果方法没有返回类型，void
                参数列表：数据类型 变量名;(申明变量) 形参; 方法计算一些未知数据，让调用者在调用方法的时候传值
                return：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束
                结果：这个结果的数据类型要和返回值类型一致
        注意：        一个是我们要明确有没有返回值
                        一个是我们要明确有没有参数列表
        3中调用方式？？
                1、直接调用
                2、输出调用 (必须有参数)
                3、赋值调用 (必须有参数)
        方法的重载 overload
                在同一个类  方法名相同 参数列表不一样 和返回值类型 修饰符无关
                参数列表:参数个数不同，参数类型不同，不同参数类型顺序不同
                重载方法调用：JVM通过方法的参数列表，调用不同的方法
               
第五天：

第六天：
类与对象 封装 构造方法：
        面向过程：注重完成事物的过程
        面向对象: 对象=事物,面向事物，注重事物的本身，而事物本身是不是有属性和行为
        例如：我们前面学习方法的的时候，我去餐厅吃饭，
                如果用面向过程：你是不是要了解事物来的过程，通过农民伯伯，小商贩，厨师，我
                如果用面向对象：我就不用管这些，就关注我自己去吃就好了
类和对象
        概念：
                类：是一组相关属性和行为的集合。
                对象：一类事物的具体实现。对象是类的实例，具有这个类的属性和行为;
                例如：手机
                        类：就相当于图纸
                        对象：就相当于生产出来的手机
        类和对象的关系
                类是对一类事物的描述，是抽象的。
                对象是一类事物的实例，是具体的。
                类是对象的模板，对象是类的实体。
类：
        属性：事物的描述 -->成员变量
        行为：事物能够做什么  -->成员方法
格式：
        public class 类名{
                //成员变量 -->和定义的变量一样，位置不同，类中方法外
                //成员方法 --> 和以前的方法相似；就是没有了static
        }
对象的使用：
        类名 对象名 = new 类名(); 数组： 数据类型[] 数组名 = new 数据类型[数组长度];
        调用
                对象名.成员变量     对象名.成员方法();
成员变量和局部变量的区别
        在类中的位置不同*
                成员变量 在类中，方法外
                局部变量 在方法中
        作用域范围不同*
                成员变量 这个类中都可以使用
                局部变量 只有这个方法中能使用，出了方法就不能用了
        初始化的默认值不同*
                成员变量：有默认值
                局部变量：没有默认值
        在内存中的位置不同
                成员变量：堆内存
                局部变量：栈内存
        生命周期不同
                成员变量：随着对象的创建而生存，随着对象的消失而消失
                局部变量：随着方法的调用而生存，随着方法的调用完毕而消失
封装       
        面向对象三大特征：封装，继承，多态
        概念：        1、把一段代码抽取出来，放到一个大括号中，形成一个单独的功能这个过程叫做封装
                        2、类中的成员变量一般情况下我们不让对象。直接调用。通过其他方式调用
        体现： 方法就是一种封装， 关键字private也是一种封装
       
        在类中我们通过你private修饰成员变量，提供public修饰的getter/setter方法
        private 是一种修饰符，最小的   可以修饰成员变量和成员方法  被private修饰的成员变量和成员方法，只能在本类中使用
        格式：       
                1、private 数据类型 变量名;
                2、提供公共的getXxx和setXxx方法 可以访问成员变量
this
        this代表所在类的当前对象的引用（地址值），即对象自己的引用
        *方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁
        格式：
                this.成员变量名; this.成员方法();
构造方法：
        概念：当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。
        格式：
                public 方法名(参数列表){ //方法名要和类名相同
                        方法体
                }
        注意：        1.        如果你不提供构造方法，系统会给出无参数构造方法。
                        2.         如果你提供了构造方法，系统将不再提供无参数构造方法。
                        3.         构造方法是可以重载的，既可以定义参数，也可以不定义参数
                       
第七天：
使用java定义好的类的步骤
        导包:          import 包名.类名
        创建对象： 类名 对象名 = new 类名();
        使用：         对象名.方法名();      对象名.变量名
Scanner
        概念： 通过Scanner可以进行键盘录入
        构造方法：
                        public Scanner(InputStream source);
        使用：
                        Scanner sc = new Scanner(System.in);
        方法：        
                        public int nextInt(); 获得手动输入的数字
                        public String next(); 获取手动输入的字符串
        使用：
                        对象名.方法名();
匿名对象
        概念： 没有变量名的对象
        格式： new 类名();
        使用： 可以当作实参，也可以当前方法的返回值，还可个调用方法和参数
        注意：一个匿名对象只能使用一次，

Random       
        概念：               
                获取随机数
        构造方法:        
                public Random() ：创建一个新的随机数生成器
        方法 ：               
                public int nextInt(int n) ：返回一个伪随机数，范围在 0 （包括）和 指定值 n （不                包括）之间的int 值。  含头不含尾
                publci int nextInt();返回一个随机数，范围是Int的范围
ArrayList
        概念：ArrayList是一个长度可变的数组，ArrayList中的每个数据称之为元素,ArrayList不断添加数据，大小也不断变大
        构造方法 ：
                public ArrayList();
        基本格式：
                ArrayList<String> strList = new ArrayList<>();
        方法：
                public boolean add(E e); 向ArrayList中添加一个元素
                public E remove(int index); 通过下标删除一个元素，返回这个下标所表示的元素
                public E get(int index); 通过下标获取这个元素
                public int size(); 获取ArrayList的长度
包装类
        基本数据类型                包装类(引用数据类型)
                byte                                Byte
                short                                Short
                int                                        Integer*
                long                                Long
                float                                Float
                long                                Long
                char                                Character*
                boolean                                Boolean
自动装箱: 基本数据类型转换成为应用数据类型这个过程叫装箱，    自动装箱就是程序自动给你转换
自动拆箱: 应用数据类型转换成为基本数据类型这个过程叫拆箱，

第八天：
String
        概念：        java.lang.String 类代表字符串。
                        Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
                        程序中所有被双引号的字符串，都是String类的对象（就是没有new,也是）
        特点：
                1、字符串的值创建出来就不能在改变
                2、因为字符串的值不能改变，所以字符串可以共享
                3、"abc" 等效于 char[] ca={'a','b','c'};
        构造方法：
                public String() ：初始化新创建的 String对象，以使其表示空字符序列。
                public String(char[] value) ：通过当前参数中的字符数组来构造新的String。
                public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。
        使用格式：
                String str1 = new String();
                String str2 = new String("abc");
                String str3 = new String(new byte[3]{97,98,99});
        常用方法：
                //比较两个字符串是否相等
                public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
                public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。
                //获取一个字符串的功能
                public int length () ：返回此字符串的长度。
                public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
                public char charAt (int index) ：返回指定索引处的 char值。
                public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
                public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
                public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
                //字符转换
                public char[] toCharArray () ：将此字符串转换为新的字符数组。
                public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
                public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。
                //拆分字符串
                public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。
static
        概念：在Java中static可以用来修饰成员变量和成员方法，被修饰的成员属于类 不在属于对象
        格式：
                static 数据类型 变量名
                修饰符 static 返回值类型 方法名(){
                        方法体;
                }
        使用格式：
                类名.变量名;
                类名.方法名();
        静态代码块
                定义成员变量的位置在成员方法外边，使用static修饰的一对大括号{}
        特点：
                是随着类的加载而加载的，且只加载一次。
                存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
                它优先于对象存在，所以，可以被所有对象共享。
Arrays
        概念：数组的操作类，里面有大量的静态方法，方便调用
        方法：
                public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。
                public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
Math
        概念：算术类
        方法：
                public static double abs(double a) ：返回 double 值的绝对值。
                public static double ceil(double a) ： 向上取整；
                public static double floor(double a) ：向下取整；
                public static long round(double a) ：四舍五入