一、面向对象
（一）继承
1.继承的好处：
(1) 提高了代码的复用性。
(2) 让类与类之间产生了关系，提供了另一个特征多态的前提。
注意： 子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super(); 如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。 如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。
2.final特点：
(1) 这个关键字是一个修饰符，可以修饰类，方法，变量。
(2) 被final修饰的类是一个最终类，不可以被继承。
(3) 被final修饰的方法是一个最终方法，不可以被覆盖。
(4) 被final修饰的变量是一个常量，只能赋值一次。
3.抽象类的特点：
(1) 抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。
(2) 抽象方法只定义方法声明，并不定义方法实现。
(3) 抽象类不可以被创建对象(实例化)。
(4) 只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
(5)，抽象类只能单继承。
4.抽象类的细节：
(1) 抽象类中是否有构造函数？有，用于给子类对象进行初始化。
(2) 抽象类中是否可以定义非抽象方法？ 可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。
(3) 抽象关键字abstract和哪些不可以共存？final , private , static
(4) 抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。
5.接 口：
如果一个抽象类中的所有方法都是抽象的，且这个抽象类中的数据成员都是final的常量，那么，这个抽象类实际上就是一个接口，即一种特殊的抽象类。对于实现该接口的子类来说，接口不提供任何实现，接口是抽象方法和常量值定义的集合。
接口具有以下特点：
(1) 接口中的常量默认为public static final，而且也只能是public static final
(2) 接口中只能定义抽象方法，这些方法默认为public abstract，而且也只能是public abstract
(3) 接口可以继承其他接口，而且可以添加新的属性和抽象方法
(4) 在接口中声明方法时不能使用static、final、private等修饰符
(5) Java不允许类的多继承，但允许接口的多继承
(6) 不允许创建接口的实例，但允许定义接口类型的引用变量，改变量要引用实现了该接口的类的实例
(7) 一个类只能继承另外一个类，但能同时实现多个接口，并且重写方法必须显示声明为public
抽象类和接口的区别：
(1) 抽象类只能被继承，而且只能单继承。 接口需要被实现，而且可以多实现。
(2) 抽象类中可以定义非抽象方法，子类可以直接继承使用。 接口中的方法都是抽象方法，需要子类去实现。
(3) 抽象类使用的是 is a 关系。 接口使用的 like a 关系。
(4) 抽象类的成员修饰符可以自定义。
接口中的成员修饰符是固定的。全都是public的。
（二）多 态
多态是面向对象特征之一，构造函数本身就具备多态性，某一种事物有不同的具体的体现。 体现：父类引用或者接口的引用指向了自己的子类对象。
//Animal a = new Cat();
多态的好处：提高了程序的扩展性。
多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)
多态的前提：
1：必须要有关系，比如继承、或者实现。
2：通常会有覆盖操作。
（三）匿名内部类
匿名内部类是没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用
这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。
匿名内部类的格式：new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。
匿名内部类的使用场景：
当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。 其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内。
二、多线程
线程的两种创建方式
（一）创建线程的第一种方式：
继承Thread ，由子类复写run方法。
步骤：
1，定义类继承Thread类；
2，目的是复写run方法，将要让线程运行的代码都存储到run方法中；
3，通过创建Thread类的子类对象，创建线程对象；
4，调用线程的start方法，开启线程，并执行run方法。
线程状态：
1新建：start()
2运行：具备执行资格，同时具备执行权；
3休眠：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格； 临时
4阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；
5消亡：stop()
例子：
package com.OpenWealth.ZSY; import java.io.*;
import java.net.*; public class TCPServer{ @SuppressWarnings("resource")
public static void main(String[] args) throws Exception{ ServerSocket ss=null;
ss=new ServerSocket(8866);
while(true){ try { Socket soc=ss.accept(); new MyPicServerThread(soc).start();//开启服务端接受图片的线程 } catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} /***
* 实现了多用户并发上传图片的服务端
* @author 支胜勇
*
*/
public static class MyPicServerThread extends Thread{ private Socket soc=null; public MyPicServerThread(Socket _soc){
this.soc=_soc;
} @Override
public void run() {
// TODO Auto-generated method stub
String clientIp=soc.getInetAddress().getHostAddress();
try { System.out.println(clientIp+"已连接！"); InputStream in=soc.getInputStream(); FileOutputStream fos=new FileOutputStream("E:\\TcpTest.png"); byte[] buff=new byte[1024]; int len=0; while((len=in.read(buff))!=-1){ fos.write(buff,0,len);
} OutputStream out=soc.getOutputStream(); out.write("图片上传成功！".getBytes()); fos.close(); soc.close(); } catch (IOException e) {
// TODO Auto-generated catch block
throw new RuntimeException("客户端"+clientIp+"上传失败");
} }
}
}
（二）创建线程的第二种方式：
实现一个接口Runnable。
步骤：
1，定义类实现Runnable接口。
2，覆盖接口中的run方法（用于封装线程要运行的代码）。
3，通过Thread类创建线程对象；
4，将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。 为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。
5，调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。
如：Ticket t = new Ticket();
直接创建Ticket对象，并不是创建线程对象。
因为创建对象只能通过new Thread类，或者new Thread类的子类才可以。 所以最终想要创建线程。既然没有了Thread类的子类，就只能用Thread类。
Thread t1 = new Thread(t); //创建线程。
只要将t作为Thread类的构造函数的实际参数传入即可完成线程对象和t之间的关联
为什么要将t传给Thread类的构造函数呢？其实就是为了明确线程要运行的代码run方法。
例子：
package com.OpenWealth.ZSY; import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.*;
import java.util.ArrayList;
import java.util.List;
import java.io.*;
public class TCPClientSocket { public static void main(String args[]) throws Exception{ BufferedReader buff=new BufferedReader(new InputStreamReader(System.in)); //同时上传多张图片
while(true){
String imgUrl=buff.readLine();
new Thread(new MyUpLoadPicClient(imgUrl,"localhost",8866)).start();
} } /**
* 实现了同时上传多张图片的客户端；可以上传多种格式的图片
* @author 支胜勇
*
*/
public static class MyUpLoadPicClient implements Runnable{ private File imgFile; private String ip; private int port; private Socket soc; private List<String> extensList=null; private OutputStream out;
private FileInputStream fis; /***
* 初始化构造方法
* @param imgUrl
* @param ip:服务器IP地址
* @param port:服务器端口
* @throws Exception
*/
public MyUpLoadPicClient(String imgUrl,String ip,int port) throws Exception{ this.imgFile=new File(imgUrl);
this.ip=ip;
this.port=port; extensList=new ArrayList<String>();
extensList.add(".jpg");
extensList.add(".png");
extensList.add(".gif");
extensList.add(".jpeg");
extensList.add(".bmp"); } public boolean isImg(){ if(!imgFile.exists()){//||!imgFile.isFile()
System.out.println("图片不存在，请重新上传！");
return false;
} if(!imgFile.isFile()){//||!imgFile.isFile()
System.out.println("不是图片文件，请重新上传！");
return false;
} String extenName=imgFile.getName().substring(imgFile.getName().lastIndexOf(".")).toLowerCase();
if(!extensList.contains(extenName)){ System.out.println("请上传jpg,png,gif,bmp,jpeg格式的图片");
return false;
} if(imgFile.length()>1024*1024*5){
System.out.println("图片过大，请上传5m以内的图片！");
return false;
} try { fis=new FileInputStream(imgFile); } catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return true;
} /***
* 执行向服务器上传图片的代码
*/
@Override
public void run() {
// TODO Auto-generated method stub
if(!isImg()){
return;
}else{
try {
this.soc=new Socket(this.ip,this.port);
out=soc.getOutputStream();
byte[] buff=new byte[1024];
int len=0;
while( (len=fis.read(buff)) != -1 ){ out.write(buff,0,len);
}
soc.shutdownOutput();//告诉服务器上传结束 InputStream in=soc.getInputStream(); byte[] bufIn=new byte[1024]; int num=in.read(bufIn); System.out.println(new String(bufIn,0,num)); fis.close();
out.close();
soc.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
}
}
}
（三）多线程安全问题的原因：
通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。
涉及到两个因素：
1，多个线程在操作共享数据。
2，有多条语句对共享数据进行运算。
原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。
解决安全问题的原理： 只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。
如何进行多句操作共享数据代码的封装呢？
java中提供了一个解决方式：就是同步代码块。
格式：
synchronized(对象) { // 任意对象都可以。这个对象就是锁。
需要被同步的代码； }
Synchronized(自己的会写得出)
wait和sleep区别：
分析这两个方法：从执行权和锁上来分析：
wait：可以指定时间也可以不指定时间。不指定时间，只能由对应的notify或者notifyAll来唤醒。
sleep：必须指定时间，时间到自动从冻结状态转成运行状态(临时阻塞状态)。
wait：线程会释放执行权，而且线程会释放锁。
Sleep：线程会释放执行权，但不是不释放锁。
三、JDK1.5新特性
（一）Collection在jdk1.5以后，有了一个父接口Iterable，这个接口的出现的将iterator方法进行抽取，提高了扩展性。
（二）增强for循环：
foreach语句，foreach简化了迭代器。
格式：// 增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器
for( 元素类型 变量名 : Collection集合 & 数组 ) { „ }
高级for循环和传统for循环的区别：
高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。
如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。 高级for循环可以遍历map集合吗？不可以。但是可以将map转成set后再使用foreach语句。
1)、作用：对存储对象的容器进行迭代： 数组 collection map
2)、增强for循环迭代数组：
String [] arr = {"a", "b", "c"};//数组的静态定义方式，只试用于数组首次定义的时候
for(String s : arr) { System.out.println(s); }
3)、单列集合 Collection：
List list = new ArrayList(); list.add("aaa"); // 增强for循环, 没有使用泛型的集合能不能使用增强for循环迭代？能 for(Object obj : list) { String s = (String) obj; System.out.println(s); }
4)、双列集合 Map：
package com.ItHeima.WeekAct; import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; public class Test5 {
public static void main(String[] args){ Map<String, String> map = new HashMap<String, String>(); map.put("a", "aaa"); // 传统方式
Set entrys = map.entrySet();
// 1.获得所有的键值对Entry对象
Iterator iter = entrys.iterator(); // 2.迭代出所有的entry
while(iter.hasNext()) { Map.Entry entry = (Entry) iter.next(); String key = (String) entry.getKey(); // 分别获得key和value String value = (String) entry.getValue(); System.out.println(key + "=" + value); } // 增强for循环迭代：原则上map集合是无法使用增强for循环来迭代的，因为增强for循环只能针对实现了Iterable接口的集合进行迭代；Iterable是jdk5中新定义的接口，就一个方法iterator方法，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，而实际上，我们可以通过某种方式来使用增强for循环。
for(Object obj : map.entrySet()) { Map.Entry entry = (Entry) obj; // obj 依次表示Entry System.out.println(entry.getKey() + "=" + entry.getValue()); }
//5）、集合迭代注意问题：在迭代集合的过程中，不能对集合进行增删操作（会报并发访问异常）；可以用迭代器的方法进行操作（子类listIterator：有增删的方法）。
//6)、增强for循环注意问题：在使用增强for循环时，不能对元素进行赋值；
int[] arr = {1,2,3}; for(int num : arr) { num = 0; //不能改变数组的值 } System.out.println(arr[1]); //
}
}
}
（三）可变参数（...）
用到函数的参数上，当要操作的同一个类型元素个数不确定的时候，可是用这个方式，这个参数可以接受任意个数的同一类型的数据。 和以前接收数组不一样的是：
以前定义数组类型，需要先创建一个数组对象，再将这个数组对象作为参数传递给函数。现在，直接将数组中的元素作为参数传递即可。底层其实是将这些元素进行数组的封装，而这个封装动作，是在底层完成的，被隐藏了。所以简化了用户的书写，少了调用者定义数组的动作。
如果在参数列表中使用了可变参数，可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败。)。
如果要获取多个int数的和呢？可以使用将多个int数封装到数组中，直接对数组求和即可。
（四）静态导入
导入了类中的所有静态成员，简化静态成员的书写。
import static java.util.Collections.*; //导入了Collections类中的所有静态成员
（五）枚举
关键字 enum
问题：对象的某个属性的值不能是任意的，必须为固定的一组取值其中的某一个； 解决办法： 1）、在setGrade方法中做判断，不符合格式要求就抛出异常； 2）、直接限定用户的选择，通过自定义类模拟枚举的方式来限定用户的输入，写一个Grade类，私有构造函数，对外提供5个静态的常量表示类的实例； 3)、jdk5中新定义了枚举类型，专门用于解决此类问题；
4)、枚举就是一个特殊的java类，可以定义属性、方法、构造函数、实现接口、继承类；
自动拆装箱：java中数据类型分为两种 ： 基本数据类型 引用数据类型(对象)
在 java程序中所有的数据都需要当做对象来处理，针对8种基本数据类型提供了包装类，如下：
int --> Integer byte --> Byte short --> Short long --> Long char --> Character
例子：
package com.OpenWealth.Traffic; /***
* 关于方向的枚举类
* @author 支胜勇
*
*/
public enum Direction { EAST{ @Override
public Direction reverse() {
// TODO Auto-generated method stub
return WEST;
} @Override
public Direction positive() {
// TODO Auto-generated method stub
return EAST;
} @Override
public Direction leftSide() {
// TODO Auto-generated method stub
return SOUTH;
} @Override
public Direction rightSide() {
// TODO Auto-generated method stub
return NORTH;
} },
SOUTH{ @Override
public Direction reverse() {
// TODO Auto-generated method stub
return SOUTH;
} @Override
public Direction positive() {
// TODO Auto-generated method stub
return NORTH;
} @Override
public Direction leftSide() {
// TODO Auto-generated method stub
return WEST;
} @Override
public Direction rightSide() {
// TODO Auto-generated method stub
return EAST;
} }
,WEST{ @Override
public Direction reverse() {
// TODO Auto-generated method stub
return WEST;
} @Override
public Direction positive() {
// TODO Auto-generated method stub
return EAST;
} @Override
public Direction leftSide() {
// TODO Auto-generated method stub
return NORTH;
} @Override
public Direction rightSide() {
// TODO Auto-generated method stub
return SOUTH;
} },NORTH{ @Override
public Direction reverse() {
// TODO Auto-generated method stub
return NORTH;
} @Override
public Direction positive() {
// TODO Auto-generated method stub
return SOUTH;
} @Override
public Direction leftSide() {
// TODO Auto-generated method stub
return EAST;
} @Override
public Direction rightSide() {
// TODO Auto-generated method stub
return WEST;
}
}; /**
* 该方向的反方向
* @return
*/
public abstract Direction reverse(); /**
* 该方向的正方向
* @return
*/
public abstract Direction positive(); /**
* 该方向的左面
* @return
*/
public abstract Direction leftSide(); /**
* 该方向的右面
* @return
*/
public abstract Direction rightSide(); }
四、高新技术
（一）反射
反射技术：其实就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节
码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。简单说：反射技术可以对一个类进行解剖。 反射的好处：大大的增强了程序的扩展性。 反射的基本步骤：
1、获得Class对象，就是获取到指定的名称的字节码文件对象。
2、实例化对象，获得类的属性、方法或构造函数。
3、访问属性、调用方法、调用构造函数创建对象。
获取这个Class对象，有三种方式：
1：通过每个对象都具备的方法getClass来获取。弊端：必须要创建该类对象，才可以调用getClass方法。
2：每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。弊端：必须要先明确该类。
前两种方式不利于程序的扩展，因为都需要在程序使用具体的类来完成。
3：使用Class类中的方法，静态的forName方法。
指定什么类名，就获取什么类字节码文件对象，这种方式的扩展性最强，只要将类名的字符串传入即可。
// 1. 根据给定的类名来获得 用于类加载
String classname = "cn.itcast.reflect.Person";// 来自配置文件
Class clazz = Class.forName(classname);// 此对象代表Person.class
// 2. 如果拿到了对象，不知道是什么类型 用于获得对象的类型
Object obj = new Person();
Class clazz1 = obj.getClass();// 获得对象具体的类型
// 3. 如果是明确地获得某个类的Class对象 主要用于传参 Class clazz2 = Person.class;
//反射的用法：
//1）、需要获得java类的各个组成部分，首先需要获得类的Class对象，获得Class对象的三种方式：
Class.forName(classname) //用于做类加载
obj.getClass() //用于获得对象的类型 类名.class 用于获得指定的类型，传参用
//2)、反射类的成员方法：
Class clazz = Person.class;
Method method = clazz.getMethod(methodName, new Class[]{paramClazz1, paramClazz2}); method.invoke();
//3)、反射类的构造函数：
Constructor con = clazz.getConstructor(new Class[]{paramClazz1, paramClazz2,...}) con.newInstance(params...)
//4)、反射类的属性：
Field field = clazz.getField(fieldName); field.setAccessible(true); field.setObject(value);
获取了字节码文件对象后，最终都需要创建指定类的对象：
创建对象的两种方式(其实就是对象在进行实例化时的初始化方式)：
1，调用空参数的构造函数：使用了Class类中的newInstance()方法。
2，调用带参数的构造函数：先要获取指定参数列表的构造函数对象，然后通过该构造函数的对象的newInstance(实际参数) 进行对象的初始化。
综上所述，第二种方式，必须要先明确具体的构造函数的参数类型，不便于扩展。所以一般情况下，被反射的类，内部通常都会提供一个公有的空参数的构造函数。
// 如何生成获取到字节码文件对象的实例对象。
Class clazz = Class.forName("cn.itcast.bean.Person"); //类加载
// 直接获得指定的类型
clazz = Person.class;
// 根据对象获得类型
Object obj = new Person("zhangsan", 19);
clazz = obj.getClass();
Object obj = clazz.newInstance(); //该实例化对象的方法调用就是指定类中的空参数构造函数，给创建对象进行初始化。当指定类中没有空参数构造函数时，该如何创建该类对象呢？请看method_2();
public static void method_2() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person");
}
//既然类中没有空参数的构造函数,那么只有获取指定参数的构造函数,用该函数来进行实例化。
//获取一个带参数的构造器。
Constructor constructor = clazz.getConstructor(String.class, int.class); //想要对对象进行初始化，使用构造器的方法newInstance();
Object obj = constructor.newInstance("zhagnsan",30); //获取所有构造器。
Constructor[] constructors = clazz.getConstructors(); //只包含公共的
constructors = clazz.getDeclaredConstructors();//包含私有的
for(Constructor con : constructors) {
System.out.println(con);
} //反射指定类中的方法： //获取类中所有的方法。
public static void method_1() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person");
Method[] methods = clazz.getMethods(); //获取的是该类中的公有方法和父类中的公有方法。
}
methods = clazz.getDeclaredMethods(); //获取本类中的方法，包含私有方法。 for(Method method : methods) { System.out.println(method); } }
//获取指定方法；
public static void method_2() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person"); //获取指定名称的方法。
}
Method method = clazz.getMethod("show", int.class, String.class);
//想要运行指定方法，当然是方法对象最清楚，为了让方法运行，调用方法对象的invoke方法即可，但是方法运行必须要明确所属的对象和具体的实际参数。 Object obj = clazz.newInstance();
method.invoke(obj, 39, "hehehe"); //执行一个方法 }
//想要运行私有方法。
public static void method_3() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person"); //想要获取私有方法。必须用getDeclearMethod();
}
Method method = clazz.getDeclaredMethod("method", null);
// 私有方法不能直接访问，因为权限不够。非要访问，可以通过暴力的方式。 method.setAccessible(true);//一般很少用，因为私有就是隐藏起来，所以尽量不要访问。 }
//反射静态方法。
public static void method_4() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person");
Method method = clazz.getMethod("function", null);
method.invoke(null, null);
}