java 学习基础总结

1. 类型转换
   1. 什么是类型转换
      1. 目标类型能与源类型兼容，如 double 型兼容 int 型，但是 char 型不能兼容 int 型
      2. 目标类型大于源类型，如 double 类型长度为 8 字节， int 类型为 4 字节，因此 double 类型的变量里直接可以存放 int 类型的数据，但反过来就不可以了  （可以强制转换）;
2. Java常量的应用
   1. 什么是常量
      1. 所谓常量，我们可以理解为是一种特殊的变量，它的值被设定后，在程序运行过程中不允许改变。(如 final 常量名 = 值;);
3. 条件语句-Switch
   1. switch使用方式
      1. switch 后面小括号中表达式的值必须是整型或字符型
      2. case 后面的值可以是常量数值，如 1、2；也可以是一个常量表达式，如 2+2 ；但不能是变量或带有变量的表达式，如 a * 2
      3. case 匹配后，执行匹配块里的程序代码，如果没有遇见 break 会继续执行下一个的 case 块的内容，直到遇到 break 语句或者 switch 语句块结束
      4. 使用示例

Switch(传入的值){

Case ’值’:

           System.Out.println(“输出”);

Break;

Case ’值’:

           System.Out.println(“输出”);

Break;

Default:

System.Out.println(“输出”);

}

1. 循环语句之-witch
   1. 如何使用witch
      1. 判断 while 后面的条件是否成立( true / false )
      2. 当条件成立时，执行循环内的操作代码 ，然后重复执行< 1 >、< 2 >， 直到循环条件不成立为止
      3. 使用示例（先判断，后执行）：

while (i< = 5) {

// 输出变量的值，并且对变量加 1，以便于进行下次循环条件判断

System.out.println(i);

i++;

}

1. 循环语句之 do...while
   1. 使用方式
      1. 先执行一遍循环操作，然后判断循环条件是否成立
      2. 如果条件成立，继续执行< 1 > 、< 2 >，直到循环条件不成立为止
      3. 示例（先执行，后判断）： 

do {

num = num + 2; // 每执行一次将数值加2，以进行下次循环条件判断

} while (num <= 50); // 满足数值在 1-50 之间时重复执行循环         

System.out.println(" 50以内的偶数之和为：" + sum );

}

1. 循环语句之 foreach
   1. 使用方式
      1. foreach 并不是 Java 中的关键字，是 for 语句的特殊简化版本，在遍历数组、集合时， foreach 更简单便捷。
      2. 示例：

for (int  k: 数组) {

         System.out.println(k);

}

1. 循环跳转语句之 break/continue
   1. 什么是break/continue
      1. break就是为了结束循环，continue是结束当前轮循环，会继续接下来的循环;
2. 写入输出Scanner
   1. 使用方式
      1. 导入Scanner  import java.Util. Scanner;
      2. Scanner input = new Scanner();
      3. 输入框 int ss =  inout.NextInt();
3. 数组定义
   1. 声明数组
      1. 语法：  数据类型[ ] 数组名；或者   数据类型 数组名[ ]；
      2. int[] scores = { 78, 93, 97, 84, 63 };或者int  scores[] = { 78, 93, 97, 84, 63 };
   2. 分配空间
      1. 简单地说，就是指定数组中最多可存储多少个元素
      2. 语法：  数组名 = new  数据类型 [ 数组长度 ];
      3. 在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成
      4. 语法：数据类型[ ]  数组名 = new  数据类型 []{78, 93, 97, 84, 63 };
4. 使用 Arrays 类操作 Java 中的数组
   1. 排序
      1. 语法：  Arrays.sort(数组名);
      2. 可以使用 sort( ) 方法实现对数组的排序，只要将数组名放在 sort( ) 方法的括号中，就可以完成对该数组的排序（按升序排列）
   2. 将数组转换为字符串
      1. 语法：  Arrays.toString(数组名);
      2. 可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开
5. Java 中的二维数组
   1. 声明数组并分配空间
      1. 
      2. 
      3. 
   2. 赋值
      1. 二维数组的赋值，和一维数组类似，可以通过下标来逐个赋值，注意索引从 0 开始；

1. 1. 1. 也可以在声明数组的同时为其赋值

如：

1. 1. 处理数组
      1. 二维数组的访问和输出同一维数组一样，只是多了一个下标而已。在循环输出时，需要里面再内嵌一个循环，即使用二重循环来输出二维数组中的每一个元素。
2. 如何定义 Java 中的方法
   1. 使用方式
      1. 一般情况下，定义一个方法的语法是：

1. 1. 1. 返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void ；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值
      2. 方法名：定义的方法的名字，必须使用合法的标识符;
2. Java 中方法的重载
   1. 什么是重载：
      1. 如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则称为方法的重载，也可称该方法被重载了。如下所示 4 个方法名称都为 show ，但方法的参数有所不同，因此都属于方法的重载：
3. static 使用之静态变量
   1. 什么是static
      1. Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问
      2. 
4. static 使用之静态初始化块
   1. 什么是静态初始化块
      1. 在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。
      2. 需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。

1. 1. 1. 
2. 封装
   1. 什么是封装
      1. 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。不允许从外部访问智能从内部直接访问，而是通过提供的方法来实现对隐藏的信息进行操作和访问。
   2. 封装的访问修饰符
      1. Private 私有的  被定义的方法或变量只允许被所在的本类调用。
      2. Protected 受保护的  被定义的方法或变量允许被本类、同包和子类调用
      3. Public 公共的  被定义的方法或变量允许被所有调用
3. Java 中的内部类
   1. 什么是内部类呢？
      1. 内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
   2. 内部类的主要作用如下：
      1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
      2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
      3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
      4. 
   3. 访问方式
      1. 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键
      2. 
4. Java 中的静态内部类
   1. 静态内部类是 static 修饰的内部类
      1. 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员（内部类 对象名= new 内部类();）
      2. 
5. 继承
   1. 什么是继承
      1. 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为
   2. 继承类型
      1. 需要注意的是 Java 不支持多继承，但支持多重继承。
      2. 
   3. 继承的初初始顺序
      1. 先执行父类的属性初始化和构造方法然后再执行子类的属性的初始化及构造方法
6. Java关键字
   1.   Final （定义的方法或变量不可修改）
      1. 不可被修改，final变量初始化必须赋给它一个值，不然会报错。（当final应用于对象引用时，而不是基本类型时，对基本类型使用final不能改变的是他的数值。而对于对象引用，不能改变的是他的引用，而对象本身是可以修改的。）
   2. Super（子类直接调用父类的方法或变量）
      1. super可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。（如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法，通过super()；关键字）;
   3. equals() （比较是否相等）
      1. Object类默认方法，比较是否相等
   4. toString()
      1. toString（）方法将对象转换为字符串
      2. 如果是使用默认继承的Object类，使用toString( ) 方法，输出对象地址。
   5. Instanceof（比较类型）
      1. java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例
   6. abstract（抽象）
      1. 抽象类的使用修饰符“abstract" 
7. 多态
   1. 什么么是多态
      1. 多态是同一个行为具有多个不同表现形式或形态的能力，
      2. 多态就是同一个接口，使用不同的实例而执行不同操作。
      3. 
   2. 多态的必要条件
      1. 继承、重写、父类类型引用指向子类对象；
   3. 引用多态
      1. 父类类型可以引用本类对象；
      2. 父类类型可以引用子类对象；
   4. 方法多态
      1. 创建本类对象时，调用的方法为本类方法；
      2. 创建子类对象时，调用的方法为子类重写的方法（如果调用的没有重写的方法则调用的是继承父类的方法）；
   5. 向上转型和向下转型
      1. 向上转型（自动类型转换）：子类转成父类的类型；
      2. 向下转型（强制类型转换）：父类转成子类的类型（须强制转换）；
8. 抽象类
   1. 什么是抽象类
      1. 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。
   2. 作用
      1. 限制规定子类必须实现某些方法，但不关注实现细节。
   3. 使用规则
      1. 抽象方法和抽象类都必须被abstract关键字修饰
      2. 抽象方法一定在抽象类中，
      3. 抽象方法：只有声明，不需要实现。
      4. 抽象类不可以用new创建对象。因为调用抽象方法没意义。
      5. 抽象类中可以包含普通的方法，也可以没有抽象方法
      6. 抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
9. java异常处理
   1. 什么是异常处理
      1. 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error
   2. try..catc..finally实现异常处理方式和自定义异常（自定义异常类必须继承Exception ）
      1. http://www.runoob.com/java/java-exceptions.html
10. Java 中的类型
    1. 创建java字符串
    2. 字符串的不变性
       1. String 对象创建后则不能被修改，是不可变的，所谓的修改其实是创建了新的对象，所指向的内存空间不同
       2. 每次 new 一个字符串就是产生一个新的对象，即便两个字符串的内容相同，使用 ”==” 比较时也为 ”false” ,如果只需比较内容是否相同，应使用 ”equals()” 方法（前面条件运算符章节讲过哦~~）
    3. String 类的常用方法
       1. 
    4. StringBuilder 类的常用方法
       1. 
    5. String和StringBuilder的区别
       1. string 对象时恒定不变的，stringBuider对象表示的字符串是可变的。stringBuilder是.net提供的动态创建string的高效方式，以克服string对象恒定性带来的性能影响。
       2. 对于简单的字符串连接操作，在性能上stringBuilder并不一定总是优于string。因为stringBuider对象创建代价较大，在字符串目标连接较少的情况下，过度滥用stringBuilder会导致性能的浪费，只有大量的或者无法预知次数的字符串操作，才考虑stringBuilder来实现。事实上，一般连接次数设置100次以内，根本看不出两者的性能差别。
       3. 当修改字符串信息时，此时不许创建对象，可以使用stringBuilder对象。
11. Java 中的包装类
    1. 基本类型和包装类之间的对应关系：
       1. 
    2. 包装类的常用方法：
       1. 
    3. 装箱
       1. 把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱
    4. 拆箱：
       1. 和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱
    5. 类型之间的转换（包装类 基本类型 String类型）
       1. 基本数据类型 ===> 包装类

1. new 类型（基本类型值）；
2. valueOf()：转化的包装类.valueOf(基本类型值);
   1. 1. String类型 ===> 包装类

1. valueOf()：转化的包装类.valueOf(基本类型值);
   1. 1. 包装类 ===> 基本数据类型：

1. 包装类变量值.包装类Value()；例如：ByteInstance.byteValue()；
   1. 1. String类型 ===> 基本数据类型

1. 包装类. parse包装类(String类型变量值)；例如：Byte.parseByte(String s)；
   1. 1. 基本类型 ===> String类型 / 包装类 ===> String类型

1. 使用包装类 :包类型.toString(byte b)；
2. 使用String类：valueOf() 方法

1. 时间
   1. Date 类的使用
      1. 使用 Date 类的默认无参构造方法创建出的对象就代表当前时间
   2. SimpleDateFormat 时间格式化
   3. Calendar 类的应用
      1. 
   4. 使用 Math 类操作数据
      1. 
   5. parse(dates)

String dates = "2018年12月25日 14时16分15秒";

       try {

                 Date date = dat.parse(dates);

                    System.out.println("当前时间是："+date);

        } catch (ParseException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       }；

1. 集合框架
   1. 什么是集合
      1. Collection 接口又有 3 种子类型，、List、Set（无序并且不可重复） 和 Queue
      2. 常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap
      3. 接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
      4. 实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
      5. 算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。
2. 使用迭代
   1. 连接地址及使用方式
      1. https://www.cnblogs.com/binbin666/p/10184723.html
   2. ArrayList使用方式
      1. 删除：remove();
      2. 查询：get();
      3. 添加：add();addAll();
      4. 修改：set(); removeAll();
3. Map
   1. Map.Entry的作用。
      1. Map.Entry是为了更方便的输出map键值对。一般情况下，要输出Map中的key 和 value  是先得到key的集合keySet()，然后再迭代（循环）由每个key得到每个value。values()方法是获取集合中的所有值，不包含键，没有对应关系。而Entry可以一次性获得这两个值。
   2. Map使用方式
      1. KeySet（）获取健值的方法
      2. Put（id，值）添加方法
      3. Get（id）获取方法
      4. Remove（id）删除方法
   3. 如何判断元素中是否存在某个属性值
      1. （查找值的时候需要重写equals和hashCode方法）（contains  containsAll）
      3. 查找第一次出现的位置indexOf();
      4. 查找最后一次出现的位置lastIndexOf();
      5. 判断是否包含key值 containskey(id);
      6. 判断是否包含value值 containsValue(object);
   4. 实现排序（需实现Comparable接口）
      1. Comparable（定义默认规则）；
      3. Comparator（临时比较规则）；
4. 线程
   1. 延长时间执行一次（Thread.sleep();）;
5. 接口
   1. 什么是接口
      1. 在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
   2. 接口规则：
      1. 接口不能用于实例化对象。
      2. 接口没有构造方法。
      3. 接口中所有的方法必须是抽象方法。
      4. 接口不能包含成员变量，除了 static 和 final 变量。
      5. 接口不是被类继承了，而是要被类实现。
      6. 接口支持多继承。
   3. 抽象类和接口的区别

1. 1. 继承父类实现接口的方法
   2. 使用匿名内部类的方式实现接