目录
- 抽象类
- 接口
- 内部类
- String类 StringBufferl和StringBuilder可变字符序列，String使用的陷阱
- 阅读API文档
- 数组的拷贝
- 多维数组与数组存储表格数据
- 冒泡排序
- 二分法查找
- 包装类
- 自动装箱和拆箱
- 包装类的缓存问题
- Date时间类,DateFormat 类和 SimpleDateFormat
- Calendar和GregorianCalendar的使用
- Math类
- Random类
- File类
- 枚举
1.抽象类
抽象方法:
使用 abstract 修饰的方法，没有方法体，只有声明
抽象类：
包含抽象方法的类就是抽象类。
抽象类的使用要点:
（1） 有抽象方法的类只能定义成抽象类
（2） 抽象类不能实例化，即不能用 new 来实例化抽象类。
（3）抽象类可以包含属性、方法、构造方法。但是构造方法不能用来 new 实例， 只能用来被子类调用。
（4） 抽象类只能用来被继承。
(5） 抽象方法必须被子类实现。
/**
* 抽象类的意义在于：为子类提供统一的、规范的模板。子类必须实现相关的抽象方法
* @author
*
*/
public abstract class Animal {
//第一：没有实现。第二：子类必须实现
abstract public void shout();
public void run() {
System.out.println("跑啊跑！");
}
public static void main(String[] args) {
//Animal a=new Animal; 错误
Animal a=new Dog();
}
}
class Dog extends Animal{
@Override
public void shout() {
System.out.println("汪汪汪！");
}
}2.接口
比抽象类还要抽象的抽象类，实现规范和具体实现的分离。
用关键字interface来声明接口
定义接口
访问修饰符：只能是 public 或默认。
接口名：和类名采用相同命名机制。
extends：接口可以多继承。
常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
方法：接口中的方法只能是：public abstract。 省略的话，也是 public abstrac
子类通过implements来实现接口中的规范。
接口的测试：
/**
* 测试接口和实现类
* @author
*
*/
public class TestInterface {
public static void main(String[] args) {
Volant v = new Angel();
v.fly();
Honest h = new GoodMan();
h.helpOther();
}
}
/**
* 飞行接口
* @author
*
*/
interface Volant{
int FLY_HEIGHY = 1000;
void fly();
}
//善良接口
interface Honest{
void helpOther() ;
}
class Angel implements Volant,Honest{
@Override
public void helpOther() { //实现类可以实现多个父接口
System.out.println("Angle.helpOther()");
}
@Override
public void fly() {
System.out.println("Angle.fly()");
}
}
class GoodMan implements Honest{
@Override
public void helpOther() {
System.out.println("GoodMan.helpOther()");
}
}
class BirdMan implements Volant{
@Override
public void fly() {
System.out.println("BirdMan.fly()");
}
}接口支持多继承。和类的继承类似，子接口 extends 父接口，会获得父接口中的
3.内部类
（1）成员内部类
可以使用private、default、protected、public任意修饰
a)非静态内部类
非静态内部类对象必须寄存在一个外部类对象里。非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。 非静态内部类不能有静态方法、静态属性和静态初始化块。 外部类的静态方法、静态代码块不能访问非静态内部类。
成员变量访问：1. 内部类属性：this.变量名。 2. 外部类属性：外部类名.this.变量名
创建内部对象：Outer.Inner inner=new Outer().new Inner();
b）静态内部类
用关键词static 修饰
.静态内部类可以访问外部类的静态成员，不能访问外部类的普通成员。 静态内部类看做外部类的一个静态成员。
创建：Outer.Inner inner = new Outer.Inner();
(2)匿名内部类
适合只需要使用一次的类。
匿名内部类没有访问修饰符。 匿名内部类没有构造方法
（3）局部内部类
定义在方法内部的，作用域只限于本方法，称为局部内部类。
4.String类
String 类又称作不可变字符序列。
String str="18"+19; //不是加法，是字符串连接符
通常比较字符串时，使用equals
System.out.println(str1.equals(str2));
String 类常用方法：
StringBuffer 和 StringBuilder ：
StringBuffer 线程安全，做线程同步检查， 效率较低。
StringBuilder 线程不安全，不做线程同步检查，因此效率较高。
String使用的陷阱：
String 一经初始化后，就不会再改变其内容了。对 String 字符串的操作实际上是对其 副本（原始拷贝）的操作，原来的字符串一点都没有改变。
String s="a";
s=s+"b"; //实际上原来的"a"字符串对象已经丢失，现在又产生了拎一个字符串s+"b"
StringBuilder 和 StringBuffer 类是对原字符串本身操作的，可以对字符串进行 修改而不产生副本拷贝或者产生少量的副本。
5.阅读API文档
· 如何下载 API 文档
下载地址，点击进入： https://www.oracle.com/java/technologies/javase-jdk8-doc-downloads.html
· 查看 API 文档
下载成功后，解压下载的压缩文件，点击进入 docs/api 下的 index.html 文件即可。
· API如何阅读
6.数组的拷贝
System.arraycopy（object src，int srcpos，object dest， int destpos，int length）
该方法可以将 src 数组里的元素值赋给 dest 数组的元素，其中 srcpos 指定从 src 数组的第几个 元素 开始赋值，length 参数指定将 src 数组的多少个元素赋给 dest 数组的元素
java.util.Arrays 类 Arrays 类包含了：排序、查找、填充、打印内容等常见的数组操作
打印数组:System.out.println(Arrays.toString(a));
7.多维数组与数组存储表格数据
多维数组可以看成以数组为元素的数组。多维数组的声明和初始化应按从低维到高维的顺序进行
二维数组的声明：
public class TestArray2 {
public static void main(String[] args) {
int[][] a = new int [3][];
a[0] = new int [2];
a[1] = new int [4];
a[2] = new int [3];
//int a1[][] = new int[][4]; //错误二维数组的初始化：
//静态初始化
int[][] a1 = {{1,2,3},{3,4},{3,5,6,7}};
System.out.println(a1[2][3]);
//动态初始化
int[][] b = new int[3][];
//a[0]={1,2,5} //错误，没有声明就初始化
b[0] = new int[] {1,2};
b[1] = new int[] {2,2};
b[2] = new int[] {2,2,3,4};
System.out.println(b[2][3]);
System.out.println(Arrays.toString(b[0]));
System.out.println(Arrays.toString(b[1]));
System.out.println(Arrays.toString(b[2]));数组存储表格
8.冒泡排序
package cn.txt.array;
import java.util.Arrays;
public class TestBubbleSort {
public static void main(String[] args) {
int[] values = {3,1,6,8,9,0,7,4,5,2};
bubbleSort(values);
System.out.println(Arrays.toString(values));
}
public static void bubbleSort(int[] values) {
int temp;
for(int i=0;i<values.length;i++) {
//定义一个布尔型的变量，标记数组是否已达到有序状态
boolean flag = true;
for(int j=0;j<values.length-1-i;j++) {
//如果前一个元素大于后一个元素，则交换两元素的值；
if(values[j]>values[j+1]) {
temp = values[j];
values[j]=values[j+1];
values[j+1]=temp;
//本趟发生了交换，表明该数组在本趟处于无序状态，需要继续比较；
flag=false;
}
}
//根据标记量的值判断数组是否有序，如果有序，则退出；无序，则继续循环。
if(flag) {
break;
}
}
}
}9.二分法查找
二分法检索又称折半检索。
二分法检索的基本思想是设数组中的元素从小到大有序地存放在数组（array）中，首 先将给定值 key 与数组中间位置上元素的关键码(key)比较，如果相等，则检索成功； 否则，若 key 小，则在数组前半部分中继续进行二分法检索; 若 key 大，则在数组后半部分中继续进行二分法检索。 这样，经过一次比较就缩小一半的检索区间，如此进行下去，直到检索成功或检索失败。
10.包装类
包装类位于 java.lang 包，八种包装类和基本数据类型的对应关系：
包装类的使用：
void testInteger() {
//基本类型转化成Integer对象
Integer int1 = new Integer(10);//已经被废弃，不推荐使用
Integer int2 = Integer.valueOf(20);//官方推荐这种写法
//Integer对象转化成int
int a = int1.intValue();
//字符串转化成Integer对象
Integer int3 = Integer.parseInt("334");
Integer int4 = new Integer("999");
//Integer对象转化成字符串
String str1 = int3.toString();
//一些常见int类型相关的常量
System.out.println("int能表示的最大整数:"+Integer.MAX_VALUE);
}11.自动装箱和拆箱
自动装箱：基本类型的数据处于需要对象的环境中时，会自动转为“对象”。
Integer i=5; //Integer i=Integer.ValueOf(5);
自动装箱调用的是 valueOf()方法，而不是 new Integer()方法
自动拆箱： 每当需要一个值时，对象会自动转成基本数据类型，没必要再去显式调用 intValue()、 doubleValue()等转型方法。
Integer i=Integer.ValueOf(5);
int j=i; // int j=i.intValue();
自动拆箱调用的 xxxValue()方法
12.包装类的缓存问题
整型、char类型所对应的包装类，在自动装箱时，对于-128~127之间的值会进行缓存处理
在创建包装类时，系统会自动创建一个缓存数组。如果数据在-128~127这个区间，那么在类加载时就已经为该区间的每个 数值创建了对象，并将这256个对象存放到一个名为cache的数组中。每当自动装箱过程发 生时（或者手动调用valueOf()时），就会先判断数据是否在该区间，如果在则直接获取数 组中对应的包装类对象的引用，如果不在该区间，则会通过new调用包装类的构造方法来创 建对象。
13.Date时间类
Date()分配一个 Date 对象，并初始化此对象为系统当前的日期和时间，可以精 确到毫秒）。 Date(long date) 分配 Date 对象并初始化此对象，以表示自从标准基准时间以 来的毫秒数。boolean equals(Object obj) 比较两个日期的相等性。 long getTime() 返回毫秒数。 StringtoString() 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中：dow 是一周中的某一天
DateFormat 类和 SimpleDateFormat:
import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class TestDateFormat {
public static void main(String[] args)throws ParseException {
//new 出 SimpleDateFormat 对象
SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
SimpleDateFormat s2 = new SimpleDateFormat("yyyy-MM-dd");
/// 将时间对象转换成字符串
String daytime = s1.format(new Date());
System.out.println(daytime);
System.out.println(s1.format(new Date()));
System.out.println(new SimpleDateFormat("hh:mm:ss").format(new Date()));
/// 将符合指定格式的字符串转成成时间对象.字符串格式需要和指定格式一致。
String time = "2049-10-1";
Date date = s2.parse(time);
System.out.println("date1:"+date);
time = "2049-10-1 20:15:30";
date = s1.parse(time);
System.out.println("date2:"+date);
}
}14.Calendar和GregorianCalendar的使用
Calendar 类是一个抽象类，为我们提供了关于日期计算的功能，比如：年、月、日、时、 分、秒的展示和计算。 GregorianCalendar 是 Calendar 的子类，表示公历
15.Math类
16.Random类
专门用来生成随机数
import java.util.Random;
public class TestRandom {
public static void main(String[] args) {
Random rand = new Random();
//随机生成[0，1）之间的double类型的数据
System.out.println(rand.nextDouble());
//随机生成 int 类型允许范围之内的整型
System.out.println(rand.nextInt());
//随机生成[0,1)之间的 float
System.out.println(rand.nextFloat());
///随机生成 false 或者 true
System.out.println(rand.nextBoolean());
//随机生成[0,10)之间的 int 类型的数据
System.out.println(rand.nextInt(10));
///随机生成[20,30)之间的 int 类型的数据
System.out.println(20+rand.nextInt(10));
}
}17.File类
java.io.File 类：代表文件和目录，用于：读取文件、创建文件、删除文件、修改文件
File 类的常见构造方法：public File(String pathnam）
18.枚举
所有的枚举类型隐性地继承自 java.lang.Enum。枚举实质上还是类！
格式： enum 枚举名 {
枚举体（常量列表）
}
