java主要特性：

1. java语言是简单的
   java语言不使用指针，而是引用。并提供了自动的废料收集，使得程序员不必为内存管理而担忧。
2. java语言是面相对象的
   java语言提供类、继承、接口等面相对象的特性
3. java语言是分布式的
4. java语言是健壮的
   java的强类型机制、异常处理、垃圾的自动收集等是java健壮性的重要保证
5. java语言是安全的
6. java语言是体系结构中立的
7. java语言是可移植的
8. java语言是解释性的
9. java语言是高性能的
10. java语言是多线程的
    在Java语言中，线程是一种特殊的对象，它必须由Thread类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为Thread(Runnable)的构造子将一个实现了Runnable接口的对象包装成一个线程，其二，从Thread类派生出子类并重写run方法，使用该子类创建的对象即为线程。
    Java语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为synchronized）。
11. java语言是动态的

java基础语法

1. 对象：
   对象是类的一个实例，有状态和行为。
2. 类
   类是一个模板，他描述一类对象的状态和行为。
3. 方法
   方法就是行为，一个类可以有很多方法。
4. 实例变量
   每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。

java修饰符

主要有两类修饰符：
访问控制修饰符：default, public , protected, private
非访问控制修饰符：final, abstract, strictfp

1. default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
2. private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
   声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
3. public : 对所有类可见。使用对象：类、接口、变量、方法
4. protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

访问控制和继承：

• 父类中声明为 public 的方法在子类中也必须为 public。
• 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
• 父类中声明为 private 的方法，不能够被继承。

非访问控制符：

1. static 修饰符，用来修饰类方法和类变量。
2. final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
3. abstract 修饰符，用来创建抽象类和抽象方法。抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
   一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
4. synchronized 修饰符。synchronized 关键字声明的方法同一时间只能被一个线程访问。
5. volatile 修饰符，volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
6. transient 修饰符，序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

java变量

主要有三种类型的变量

1. 局部变量
   在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
   访问修饰符不能用于局部变量；
   局部变量是在栈上分配的。
   局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
2. 类变量(静态变量)
   类变量也声明在类中，方法体之外，但必须声明为static类型。
   静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。静态变量可以通过：ClassName.VariableName的方式访问。
3. 成员变量(非静态变量)
   成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
   实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；

成员变量与类变量的区别：

1. 两个变量的生命周期不同
   成员变量随着对象的创建而存在，随着对象的回收而释放。
   静态变量随着类的加载而存在，随着类的消失而消失。
2. 调用方式不同
   成员变量只能被对象调用。
   静态变量可以被对象调用，还可以被类名调用。
3. 别名不同
   成员变量也称为实例变量。
   静态变量也称为类变量。
4. 数据存储位置不同
   成员变量存储在堆内存的对象中，所以也叫对象的特有数据。
   静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

特点：

1. 想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
2. 被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。
3. 静态随着类的加载而加载。而且优先于对象存在。

弊端：

1. 有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。
2. 静态方法只能访问静态成员，不可以访问非静态成员。
   因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
3. 静态方法中不能使用this，super关键字。
   因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

成员分两种：

1. 成员变量。（数据共享时静态化）
   该成员变量的数据是否是所有对象都一样：
   如果是，那么该变量需要被静态修饰，因为是共享的数据。
   如果不是，那么就说这是对象的特有数据，要存储到对象中。
2. 成员函数。（方法中没有调用特有数据时就定义成静态）
   如果判断成员函数是否需要被静态修饰呢？
   只要参考，该函数内是否访问了对象中的特有数据：
   如果有访问特有数据，那方法不能被静态修饰。
   如果没有访问过特有数据，那么这个方法需要被静态修饰。

成员变量与局部变量的区别：

1. 声明位置不同
   成员变量也就是属性，在类中声明的。
   局部变量，在方法中声明或代码块中声明。
2. 初始值不同
   成员变量如果没有赋值则是有默认值的，数据类型不同则默认值不同。
   局部变量是没有默认值，也就是说必须先声明，再赋值，最后才使用。
3. 在一个类中，局部变量可以与成员变量同名，但是局部变量优先,如果非要访问成员变量的属性，则必须使用 this.color
   this 代表当前这个对象，也就是当前谁调用这个方法则这个对象就是谁。
   对象与引用区别
   对象是具体的一个实例，如：new Student(); new 表示创建一个对象，并在堆内存中开辟一块空间。
   引用名称是存放的对象的地址。

构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

源文件声明规则

1. 一个源文件中只能有一个public类
2. 一个源文件可以有多个非public类
3. 源文件的名称应该和public类的类名保持一致。
4. 如果一个类定义在某个包中，那么package语句应该在源文件的首行。
5. 如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
6. import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

java基本数据类型

变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。

java的两大数据类型：

1. 内置数据类型
2. 引用数据类型

内置数据类型：

自动类型转换：
必须满足转换前的数据类型的位数要低于转换后的数据类型
byte,short,char—> int —> long—> float —> double
char c1='a';//定义一个char类型
int i1 = c1;//char自动类型转换为int

强制类型转换：
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度。
格式：(type)value type是要强制类型转换后的数据类型
int i1 = 123;
byte b = (byte)i1;//强制类型转换为byte

引用类型：
所有引用类型的默认值都是null。

类型转换的方法：

1. 一般情况下，我们首先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换了。
   当希望把float型转换为double型时：

float f1=100.00f;
Float F1=new Float(f1);//Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)
double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法

2. 其它类型向字符串的转换

• 调用类的串转换方法:X.toString();
• 自动转换:X+"";
• 使用String的方法:String.valueOf(X);

3. 字符串作为值,向其它类型的转换

• 先转换成相应的封装器实例,再调用对应的方法转换成其它类型
  例如，字符中"32.1"转换double型的值的格式为:new Float("32.1").doubleValue()。也可以用:Double.valueOf("32.1").doubleValue()
• 静态parseXXX方法

String s = "1";
byte b = Byte.parseByte( s );
short t = Short.parseShort( s );
int i = Integer.parseInt( s );
long l = Long.parseLong( s );
Float f = Float.parseFloat( s );
Double d = Double.parseDouble( s );

4. Date类与其它数据类型的相互转换

import java.text.SimpleDateFormat;

java.util.Date date = new java.util.Date();
//如果希望得到YYYYMMDD的格式
SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMdd");
String dateFormat=sy1.format(date);
//如果希望分开得到年，月，日
SimpleDateFormat sy=new SimpleDateFormat("yyyy");
SimpleDateFormat sm=new SimpleDateFormat("MM");
SimpleDateFormat sd=new SimpleDateFormat("dd");
String syear=sy.format(date);
String smon=sm.format(date);
String sday=sd.format(date);

java运算符

• 算术运算符
• 关系运算符
• 位运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。
后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算。

int a , b;
a = 10;
// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
b = (a == 1) ? 20 : 30;

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

java循环

• while循环
• do...while循环
• for循环

while( 布尔表达式 ) {
  //循环内容
}
do {
       //代码语句
}while(布尔表达式);
for(初始化; 布尔表达式; 更新) {
    //代码语句
}
for(声明语句 : 表达式)
{
   //代码句子
}

java分支结构

• if语句
• switch语句

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
}else {
   //如果以上布尔表达式都不为true执行代码
}
switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

java Number类、Math类、Character类、String类、StringBuffer类、StringBuilder 类

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。Number 类属于 java.lang 包。
java中的自动装箱与拆箱：
简单一点说，装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。
xxxValue() 方法用于将 Number 对象转换为 xxx基本 数据类型的值并返回。（byteValue() ，doubleValue()，floatValue()，intValue() ，longValue()，shortValue()。以上各函数不接受任何的参数）
equals()方法判断number对象是否与参数相等。
== 它比较的是对象的地址
equals 比较的是对象的内容
valueOf()方法返回一个 Number 对象指定的内置数据类型

Integer x = 5;
x.byteValue() #拆箱，包装类转原生类
Integer.valueOf(128); #装箱，原生类转包装类
Math.cos(0) #0度的余弦值
Math.PI
Character ch = new Character('a');
String site = "www.runoob.com";
int len = site.length();
string1.concat(string2); #连接字符串
"Hello," + " runoob" + "!" #连接字符串
System.out.printf("%s,%d",变量1,变量2)
String fs = String.format("%s,%d",变量1,变量2)
StringBuffer sBuffer = new StringBuffer("菜鸟教程官网：");
sBuffer.append("www"); #append()方法 效果类似字符串的拼接

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。
Java语言为内置数据类型char提供了包装类Character类。Character类属于 java.lang 包
String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。
String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
length() 方法，length 属性和 size() 方法的区别:

1. length() 方法是针对字符串来说的，要求一个字符串的长度就要用到它的length()方法；
2. length 属性是针对 Java 中的数组来说的，要求数组的长度可以用其 length 属性；
3. Java 中的 size() 方法是针对泛型集合说的, 如果想看这个泛型有多少个元素, 就调用此方法来查看!
   Java：String、StringBuffer 和 StringBuilder 的区别：
   String：字符串常量，字符串长度不可变。Java中String 是immutable（不可变）的。用于存放字符的数组被声明为final的，因此只能赋值一次，不可再更改。String 是被 final 修饰的，他的长度是不可变的。
   StringBuffer：字符串变量（Synchronized，即线程安全）。如果要频繁对字符串内容进行修改，出于效率考虑最好使用 StringBuffer，如果想转成 String 类型，可以调用 StringBuffer 的 toString() 方法。Java.lang.StringBuffer 线程安全的可变字符序列。在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。可将字符串缓冲区安全地用于多个线程。
   StringBuilder：字符串变量（非线程安全）。在内部 StringBuilder 对象被当作是一个包含字符序列的变长数组。
   基本原则：

• 如果要操作少量的数据用 String ；
• 单线程操作大量数据用StringBuilder ；
• 多线程操作大量数据，用StringBuffer。
  当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

#创建字符串
greeting = new String("hello");
String greeting = "hello";
char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
String helloString = new String(helloArray);  

java数组

Java 语言中提供的数组是用来存储固定大小的同类型元素。
数组可以作为参数传递给方法。
数组作为函数的返回值。

#创建数组
int[] intarray = new int[5];
int[] intarray = {1, 2, 3, 4, 5};
int[] intarray = new int[]{1, 2, 3, 4, 5};
#多维数组
String str[][] = new String[3][4];
int a[][] = new int[2][3];
a[0] = new int[2];
a[1] = new int[2];
a[0][0] = 1;
a[0][1] = 2;
a[1][0] = 3;
a[1][1] = 4;
#排序
import java.util.Arrays;
Arrays.sort(a);

java Date类、Calendar类、SimpleDateFormat类、Thread类

java.util 包提供了 Date 类来封装当前的日期和时间。

import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.Thread;
import java.util.Calendar;

 // 初始化 Date 对象
Date date = new Date();
// 使用 toString() 函数显示日期时间
System.out.println(date.toString());
String sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date)
Date dt = new SimpleDateFormat("yyyy-MM-dd").parse("2018-06-23") #字符串转Date类
Thread.sleep(1000*3);   // 休眠3秒
Calendar c = Calendar.getInstance();//默认是当前日期
c.setTime(dt);
c.add(Calendar.DATE, 10); #把c1对象的日期加上10，也就是c1也就表示为10天后的日期
c.add(Calendar.DATE, -10); #把c1对象的日期减去10，也就是c1也就表示为10天前的日期
Date date = c.getTime();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);

java正则表达式

java.util.regex 包主要包括以下三个类：

• Pattern 类：
  pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。
• Matcher 类：
  Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
• PatternSyntaxException：
  PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

import java.util.regex.Pattern;
boolean isMatch = Pattern.matches(pattern, content);#pattern是正则表达式，content是待匹配的字符串，返回true或false

Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(content);
m.find()
m.group(int) #返回匹配到的字符串
m.matches() #若pattern可以匹配整个字符串则返回true
m.lookingAt() #若pattern从一开始就能匹配就返回true
m.replaceAll(replacestring)#替换所有匹配到的内容

java方法

main 方法是被 JVM 调用的。
一个类的两个方法拥有相同的名字，但是有不同的参数列表，这叫做方法重载，重载的方法必须拥有不同的参数列表。
当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
不管你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，它把所有成员初始化为0。
一旦你定义了自己的构造方法，默认构造方法就会失效。
Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。

#语法
修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}
System.out.println() #这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。
typeName... parameterName #可变参数语法，一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

java Stream、File、IO

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
br.readLine();#读取控制台的输入
System.out.println()
System.out.print()
System.out.write()#输出到控制台
#读取文件的两种方式
InputStream f = new FileInputStream("C:/java/hello");
File f = new File("C:/java/hello");
InputStream is = new FileInputStream(f);
is.read()
#写入数据到文件的两种方式
OutputStream f = new FileOutputStream("C:/java/hello");
File f = new File("C:/java/hello");
OutputStream os = new FileOutputStream(f);
os.write("字节数据")
File类的几种常用方法
File f = new File("C:/java/hello");
f.getName()
f.exists()
f.isDirectory()
f.isFile()
f.length() #文件的长度
f.delete()
f.listFiles()#列出该目录下所有的文件和文件夹
f.mkdirs()
f.toString()
FileWriter类#FileWriter 类从 OutputStreamWriter 类继承而来。该类按字符向流中写入数据。
FileWriter fw = new FileWriter(File file, boolean append)
FileWriter fw = new FileWriter("file_path")
fw.write("写入数据")
fw.close()
FileReader类#FileReader类从InputStreamReader类继承而来。该类按字符读取流中数据。
FileReader fr = new FileReader(File file)
FileReader fr = new FileReader("file_path", boolean append)
char[] c = new char[(int) f.length()];
fr.read(c);
for(char i: c)
  System.out.print(i);
fr.close();

总结：
以InputStream（输入）/ OutputStream（输出）为后缀的是字节流；
以Reader（输入）/ Writer（输出）为后缀的是字符流。

io流

#I/O流的典型使用方式
#读文件
public static String read(String filename) throws IOException {
        BufferedReader in = new BufferedReader(new FileReader(filename));
        String s;
        StringBuffer sb = new StringBuffer();
        while ((s = in.readLine()) != null)
            sb.append(s + "\n");
        in.close();
        return sb.toString();
    }
#写文件
public static void write(String filename) throws IOException {
        BufferedReader bf = new BufferedReader(new StringReader("abcdef\nabcdef"));
        //PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(filename)));
        PrintWriter pw = new PrintWriter(filename); //简写方式，仍旧是在进行缓存
        String s;
        while ((s = bf.readLine()) != null) {
            //pw.write(s + "\n");
            pw.println(s); //自动换行
        }
        pw.close();
    }
#标准输入
public static void stdIn() throws IOException {
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
        String s;
        while ((s = stdin.readLine()) != null && s.length() != 0)
            System.out.println(s);
    }
#标准输出
public static void stdOut() throws IOException {
        PrintWriter pw = new PrintWriter(System.out, true);
        pw.println("hello world");
    }

java Scanner类

// 从键盘接收数据
Scanner scan = new Scanner(System.in);
// 判断是否还有输入
if (scan.hasNextLine()) {
  String str2 = scan.nextLine();  // nextLine方式接收字符串
  System.out.println("输入的数据为：" + str2);
}
scan.close();

java异常处理

所有的异常类是从 java.lang.Exception 类继承的子类。

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

自定义异常：

• 所有异常都必须是 Throwable 的子类。
• 如果希望写一个检查性异常类，则需要继承 Exception 类。
• 如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。

image

throws 用于方法上，可抛出多个异常，每个异常的类名用逗号隔开。
throw 用在代码块中，后面跟着异常的对象，该对象可以是自定义异常，且 throw 使用在方法中。
public void test() throws Exception {
throw new Exception();
}

java继承

维护性提高，代码也更加简洁，提高代码的复用性。
继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

继承的特性：

• 子类拥有父类非private的属性，方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。

super 与 this 关键字：

• super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。java 中若要在子类调用父类的方法，需使用关键字super。super 语句必须是子类构造方法的第一条语句。不能在子类中使用父类构造方法名来调用父类构造方法。 父类的构造方法不被子类继承。调用父类的构造方法的唯一途径是使用 super 关键字，如果子类中没显式调用，则编译器自动将 super(); 作为子类构造方法的第一条语句。这会形成一个构造方法链。静态方法中不能使用 super 关键字。如果子类覆盖或重写了父类的方法，则只有使用 super 才能在子类中调用父类中的被重写的方法。java文件被编译成class文件时，在子类的所有构造函数中的第一行（第一个语句）会默认自动添加 super() 语句，在执行子类的构造函数前，总是会先执行父类中的构造函数。子类的所有构造方法内部， 第一行会（隐式）自动先调用父类的无参构造函数super()；如果子类构造方法第一行显式调用了父类构造方法，系统就不再调用无参的super()了。
  super 表示使用它的类的父类。super 可用于：
  调用父类的构造方法；(super();或者super(参数列表);)
  调用父类的方法（子类覆盖了父类的方法时）；(super.方法名(参数列表);)
  访问父类的数据域（可以这样用但没有必要这样用）。
• this关键字：指向自己的引用。
  this 关键字表示当前对象。可用于：
  调用当前类的构造方法，并且必须是方法的第一条语句。如：this(); 调用默认构造方法。this(参数); 调用带参构造方法。
  限定当前对象的数据域变量。一般用于方法内的局部变量与对象的数据域变量同名的情况。如 this.num = num。this.num 表示当前对象的数据域变量 num，而 num 表示方法中的局部变量。

final关键字：

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写，实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。

构造器：

子类不能继承父类的构造器（构造方法或者构造函数），如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

java重写与重载

没有override关键字，这和其他语言有区别。

方法的重写规则：

• 参数列表必须完全与被重写方法的相同；
• 返回类型必须完全与被重写方法的返回类型相同；
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
• 父类的成员方法只能被它的子类重写。
  *声明为final的方法不能被重写。
• 声明为static的方法不能被重写，但是能够被再次声明。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
• 构造方法不能被重写。
• 如果不能继承一个方法，则不能重写这个方法。

重载规则:

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

重写与重载之间的区别:

java多态

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作。

多态的优点

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象(Parent p = new Child();)(当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。)

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

多态的实现方式：

• 重写
• 接口
• 抽象类和抽象方法

java抽象类与抽象方法

关键字：abstract
如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

抽象类总结规定

1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
2. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
4. 构造方法，类方法（用static修饰的方法）不能声明为抽象方法。
5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

java封装

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点

1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节。

实现java封装的步骤：

1. 修改属性的可见性来限制对属性的访问（一般限制为private）。
2. 2. 对每个值属性提供对外的公共方法(getter，setter)访问，也就是创建一对赋取值方法，用于对私有属性的访问。

class a{
private int age;
public void setAge(int newAge){
    age = newAge;
  }
public int getAge(){
    return age;
  }
}

java接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类的区别：

• 接口不能用于实例化对象。
• 接口没有构造方法。
• 接口中所有的方法必须是抽象方法。
• 接口不能包含成员变量，除了 static 和 final 变量。
• 接口不是被类继承了，而是要被类实现。
• 接口支持多继承。

接口特性:

• 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
• 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别

• 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
• 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

java包

package pkg1[．pkg2[．pkg3…]];
import package1[.package2…].(classname|*);
包的作用

1. 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2. 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3. 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

java数据结构

Java工具包提供了强大的数据结构。在Java中的数据结构主要包括以下几种接口和类：

• 枚举（Enumeration）
• 位集合（BitSet）
• 向量（Vector）
• 栈（Stack）
• 字典（Dictionary）
• 哈希表（Hashtable）
• 属性（Properties）

import java.util.Enumeration;
import java.util.Vector;
import java.util.BitSet;
import java.util.Stack;
#Enumeration
Enumeration<String> days;
#boolean hasMoreElements( )
#测试此枚举是否包含更多的元素。
#Object nextElement( )
#如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。
while (days.hasMoreElements()){
         System.out.println(days.nextElement()); 
}

#Vector类实现了一个动态数组。
#Vector是同步访问的。
Vector类支持4种构造方法。
第一种构造方法创建一个默认的向量，默认大小为10：Vector()
第二种构造方法创建指定大小的向量：Vector(int size)
第三种构造方法创建指定大小的向量，并且增量用incr指定. 增量表示向量每次增加的元素数目: Vector(int size,int incr)
第四种构造方法创建一个包含集合c元素的向量：Vector(Collection c)

#栈是Vector的一个子类，它实现了一个标准的后进先出的栈。
boolean empty() 
测试堆栈是否为空。
Object peek( )
查看堆栈顶部的对象，但不从堆栈中移除它。
Object pop( )
移除堆栈顶部的对象，并作为此函数的值返回该对象。
Object push(Object element)
把项压入堆栈顶部。

#Dictionary 类是一个抽象类，用来存储键/值对

#Hashtable是原始的java.util的一部分， 是一个Dictionary具体的实现 。
#支持同步。
#Hashtable在哈希表中存储键/值对。

#Properties 继承于 Hashtable.表示一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。
#Properties类定义了两个构造方法. 第一个构造方法没有默认值: Properties()
#第二个构造方法使用propDefault 作为默认值。两种情况下，属性列表都为空：Properties(Properties propDefault)

java集合框架

image

1. Collection 接口
   Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。
   Collection 接口存储一组不唯一，无序的对象。

2. List 接口
   List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。
   List 接口存储一组不唯一，有序（插入顺序）的对象。

3. Set
   Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。
   Set 接口存储一组唯一，无序的对象。

4. SortedSet
   继承于Set保存有序的集合。

5. Map
   Map 接口存储一组键值对象，提供key（键）到value（值）的映射。

6. Map.Entry
   描述在一个Map中的一个元素（键/值对）。是一个Map的内部类。

7. SortedMap
   继承于 Map，使 Key 保持在升序排列。

Set和List的区别

1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。

2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。

3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

集合实现类（集合类）:

1. LinkedList
   该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，LinkedList 查找效率低。
2. ArrayList
   该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。
3. HashSet
   该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。
4. TreeSet
   该类实现了Set接口，可以实现排序等功能。
5. HashMap
   HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。
   该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。
6. TreeMap
   继承了AbstractMap，并且使用一颗树。

List<String> list=new ArrayList<String>();
list.add("Hello");#添加元素
String[] strArray=new String[list.size()];
list.toArray(strArray);
Iterator<String> ite=list.iterator();

Map<String, String> map = new HashMap<String, String>();
map.put("1", "value1");#添加元素
map.keySet()#得到所有key
map.values()
for (Map.Entry<String, String> entry : map.entrySet()) {
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
}

java泛型

下面是定义泛型方法的规则：

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的<E>）。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

public static < E > void printArray( E[] inputArray ){方法体} #泛型方法
public static <T extends Comparable<T>> T maximum(T x, T y, T z){}#上界
public class Box<T> {}#泛型类
public interface Generator<T> {T next();} #泛型接口
public static void getData(List<?> data) {}#类型通配符

<? extends T>和<? super T>的区别：

• <? extends T>表示该通配符所代表的类型是T类型的子类。
• <? super T>表示该通配符所代表的类型是T类型的父类。

java序列化

Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。
将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。
一个类的对象要想序列化成功，必须满足两个条件：

• 该类必须实现 java.io.Serializable 对象。(public class Employee implements java.io.Serializable)
• 该类的所有属性必须是可序列化的。如果有一个属性不是可序列化的，则该属性必须注明是短暂的。(public transient int SSN;)

java注释

Java 支持三种注释方式。前两种分别是 // 和 /* /，第三种被称作说明注释，它以 /* 开始，以 /结束。
说明注释允许你在程序中嵌入关于程序的信息。你可以使用 javadoc 工具软件来生成信息，并输出到HTML文件中。
说明注释，使你更加方便的记录你的程序信息。
在开始的 /* 之后，第一行或几行是关于类、变量和方法的主要描述。
之后，你可以包含一个或多个何种各样的 @ 标签。每一个 @ 标签必须在一个新行的开始或者在一行的开始紧跟星号(*).
多个相同类型的标签应该放成一组。例如，如果你有三个 @see 标签，可以将它们一个接一个的放在一起。

Java枚举类型

enum关键字

public enum Spiciness {
  NOT, MILD, MEDIUM, HOT, FLAMING
}
Spiciness howHot = Spiciness.MEDIUM;
System.out.println(howHot); //output: MEDIUM
Spiciness.values(); //output: {NOT, MILD, MEDIUM, HOT, FLAMING}，返回一个数组
howHot.ordinal(); // 2, 返回对应的下标，下标从0开始。

java 并发

Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
线程状态图：

线程共包括以下 5 种状态:

1. 新建状态(New): 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。

2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。

3. 运行状态(Running): 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。

4. 阻塞状态(Blocked): 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

(01) 等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。
(02) 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
(03) 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5. 死亡状态(Dead): 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

Java 提供了三种创建线程的方法：

1. 实现Runnable接口，重写run()；
2. 继承Thread抽象类，重写run();
3. 实现Callable接口，重写call()，并且有返回值。

class ThreadDemo extends Thread {
    ThreadDemo() {
        System.out.println("Creating " + Thread.currentThread().getName());
    }
    public void run() {
        System.out.println("Running " +  Thread.currentThread().getName() );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + Thread.currentThread().getName() + ", " + i);
                // 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  Thread.currentThread().getName() + " interrupted.");
        }
        System.out.println("Thread " +  Thread.currentThread().getName() + " exiting.");
    }

}
class RunnableDemo implements Runnable {
    RunnableDemo() {
        System.out.println("Creating " + Thread.currentThread().getName());
    }
    public void run() {
        System.out.println("Running " +  Thread.currentThread().getName() );
        try {
            for(int i = 4; i > 0; i--) {
                System.out.println("Thread: " + Thread.currentThread().getName() + ", " + i);
                // 让线程睡眠一会
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {
            System.out.println("Thread " +  Thread.currentThread().getName() + " interrupted.");
        }
        System.out.println("Thread " +  Thread.currentThread().getName() + " exiting.");
    }

}
class CallableDemo implements Callable<String> {
    int time;
    public CallableDemo(int time ) {
        this.time = time;
    }
    public String call() throws InterruptedException {
        List<Integer> list = new ArrayList<>();
       for (int i = 1; i < time / 5; i++) {
           System.out.println(Thread.currentThread().getName() + "-" + i);
           Thread.sleep(time);
           list.add(i);
       }
       return list.toString();
    }
}
class ThreadPoolDemo implements Callable<Integer> {
    private int x;
    private int y;
    public ThreadPoolDemo(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public Integer call() throws InterruptedException {
        for (int i = 1; i < 3; i++) {
            System.out.println(Thread.currentThread().getName() + "-" + i);
            Thread.sleep(50);
        }
        return x + y;
    }
}
public class ThreadTest {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        //
        for (int i = 1; i < 3; i++) {
            Thread t1 = new Thread(new ThreadDemo(), "Thread-" + i);
            System.out.println("Starting " + Thread.currentThread().getName());
            t1.start();
            //t1.join();
        }
        //
        for (int i = 1; i < 3; i++) {
            Thread t1 = new Thread(new RunnableDemo(), "Thread-" + i);
            System.out.println("Starting " + Thread.currentThread().getName());
            t1.start();
            //t1.join();
        }
        //
        for (int i = 1; i < 3; i++) {
            CallableDemo cd = new CallableDemo(50 / i);
            FutureTask<String> ft = new FutureTask<>(cd);
            Thread t = new Thread(ft, "Thread-" + i);
            t.start();
            System.out.println(ft.get()); //有问题，添加这一行，就变成串行了。

        }
        //
        ExecutorService threadPool = Executors.newFixedThreadPool(2); //创建有2个线程的线程池
        for (int i = 1; i < 6; i++) {
            ThreadPoolDemo ed = new ThreadPoolDemo(i, i);
            Future<Integer> result = threadPool.submit(ed);
            System.out.println(result.get()); //有问题，添加这一行，就变成串行了。
        }
        threadPool.shutdown(); //关闭线程池，不然程序不会终止
    }
}