关注我，每天都有优质技术文章推送，工作，学习累了的时候放松一下自己。
欢迎大家关注我的微信公众号：「醉翁猫咪」
什么是接口？
接口的基本语法
接口的基本语法（一）
使用interface定义
接口当中的方法都是抽象方法；
接口当中的方法都是public权限
接口中全是抽象函数，不能生成对象
interface USB{
public void read();
public void write();
}
class USBPhone implements USB{
//复写
public void read(){
System.out.println(“USBPhone read”);
}
public void write(){
System.out.println(“USBPhone write”);
}
}
class Test{
public static void main(String args[]){
USBPhone usbPhone = new USBPhone();
USB usb = usbPhone;
usb.read();
usb.write();
}
}
接口的基本语法（二）
实现接口使用implements关键字
一个类可以实现多个接口
一个接口可以继承多个接口
class Phone implements USB,WiFi{
public void read(){
System.out.println(“USB read”);
}
public void write(){
System.out.println(“USB write”);
}
public void open(){
System.out.println(“USB open”);
}
public void close(){
System.out.println(“USB close”);
}
}
interface USB{
public void read();
public void write();
}
interface WiFi{
public void open();
public void close();
}
class Test{
public static void main(String args[]){
Phone phone = new Phone();
USB usb = phone;
usb.read();
usb.write();
WiFi wifi = phone;
wifi.open();
wifi.close();
}
}
接口可以继承多个接口
什么是接口的应用
为什么要用接口
工厂方法模式
class HPPrinter implements Printer{
public void open(){
System.out.println(“HP open”);
}
public void close(){
System.out.println(“HP close”);
}
public void print(String s){
System.out.println(“HP print–>” + s);
}
}
class CanonPrinter implements Printer{
private void clean(){
System.out.println(“clean”);
}
public void close(){
this.clean();
System.out.println(“Canon close”);
}
public void open(){
System.out.println(“Canon opern”);
}
public void print(String s){
System.out.println(“Canon print—>”+s);
}
}
interface Printer{
public void open();
public void close();
public void print(String s);
}
class Test{
public static void main(String args[]){
//根据用户的选择，生成相应的打印机对象
//并且向上转型为Printer类型
//Printer getPrinter(int flag)
printer.open();
printer.print(“test”);
printer.close();
}
}
打印机工厂
class PrinterFactory{
public static Printer getPrinter(int flag){
Printer printer = null;
//int flag = 0;
if(flag == 0){
printer = new HPPrinter();
}
else(flag == 1){
printer = new CanonPrinter();
}
return printer;
}
}
class Test{
public static void main(String args[]){
//根据用户的选择，生成相应的打印机对象
//并且向上转型为Printer类型
//Printer getPrinter(int flag)
int flag = 1;
Printer printer = PrinterFactory.getPrinter(flag);
printer.open();
printer.print(“test”);
printer.close();
}
}
java当中的异常
什么是异常
异常的分类
try…catch…finally结构的使用方法
异常：中断了正常指令流的事件。
Throwable Exception Error
class TestCheck{
public static void main(String args[]){
//check exception
Thread.sleep(1000);
}
}
属于check异常
class Test{
public static void main(String args[]){
System.out.println(1);
try{
System.out.println(2);
int i = 1 / 0;
System.out.println(3);
}
catch(Exception e){
e.printStackTrace();
System.out.println(4);
}
finally{
System.out.println(“finally”);
}
System.out.println(5);
}
}
class TestCheck{
public static void main(String args[]){
try{
Thread.sleep(1000);
}
catch(Exception e){
e.printStackTrace();
}
}
}
30总结
程序员对Error无能为力，只能处理Exception
对异常的处理关系到系统的健壮性
使用try…catch…finally来处理可能出现异常的代码
throw的作用
throws的作用
class User{
private int age;
public void setAge(int age) throws Exception{
if(age<0){
RuntimeException e = new RuntimeException(“年龄不能为负数”);
throw e;
}
this.age=age
}
}
class Test{
public static void main(String args[]){
User user = new User();
try{
user.setAge(-20);
}
catch(Exception e){
System.out.println(e);
}
}
}
throws Exception谁调用谁处理
32Java当中的IO
IO操作的目标
IO的分类方法
读取文件和写入文件的方法
IO操作的目标
从数据源当中读取数据，以及将数据写入到数据目的地当中。
IO的分类：
第一种分法：
输入流
输出流
第二种分类：
字节流
字符流
第三种分类：
节点流
处理流
IO当中的核心类
InputStream OutputStream FileInputStream FileOnputStream
字节流的核心类
InputStream OutputStream所有字节流的父类 抽象类，是不能生成对象的，子类可以生成对象。
核心类的核心方法
InputStream:
int read(byte[] b,int off,int len)
OutputStream:
void write(byte[] b,int off,int len)
//第一步：导入类，
import java.io.*;
class Test{
public static void main(String args[]){
//声明输入流引用
FileInputStream fis = null;
//读取文件数据的 输入流，FileInputStream
try{
//生成代表输入流的对象
fis = new FileInputStream(“e:/src/from.text”);
//读取数据
//生成一个字节数组
byte [] buffer = new byte[100];
//调用输入流对象的read方法，读取数据
//0,代表偏移量，如果是5，那么就从第五个读取
fis.read(buffer,0,buffer.length);
for(int i = 0;i<buffer.length;i++){
System.out.println(buffer[i]);
}
}
catch(Exception e){
System.out.println(e);
}
}
}
字符表达
import java.io.*;
class Test{
public static void main(String args[]){
//声明输入流引用
FileInputStream fis = null;
//声明输出流的引用
FileOutputStream fos = null;
//读取文件数据的 输入流，FileInputStream
try{
//生成代表输入流的对象
fis = new FileInputStream(“e:/src/from.txt”);
//生成代表输出流的对象
fos = new FileOutputStream(“e:/src/to.txt”);
//读取数据
//生成一个字节数组
byte [] buffer = new byte[100];
//调用输入流对象的read方法，读取数据
//0,代表偏移量，如果是5，那么就从第五个读取
int temp = fis.read(buffer,0,buffer.length);
fos.write(buffer,0,temp);
/* String s = new String(buffer);
//调用一个String对象的trim方法，将会去除掉这个字符串的
//首尾空格和空字符
s = s.trim();
System.out.println(s);*/
}
catch(Exception e){
System.out.println(e);
}
}
}
32总结：IO系统的主要目标是为了对数据进行读写操作
数据的流向以JAVA程序为参照物
IO流可以有三种分类方法
read方法和write方法
33Java当中的IO（二）
大文件的读写方法
字符流的使用方法
import java.io.*;
class Test{
public static void main(String args[]){
//声明输入流引用
FileInputStream fis = null;
//声明输出流的引用
FileOutputStream fos = null;
//读取文件数据的 输入流，FileInputStream
try{
//生成代表输入流的对象
fis = new FileInputStream(“e:/src/from.txt”);
//生成代表输出流的对象
fos = new FileOutputStream(“e:/src/to.txt”);
//读取数据
//生成一个字节数组
byte [] buffer = new byte[1024];
while(true){
int temp = fis.read(buffer,0,buffer.length);
if(temp == -1){
break;
}
fos.write(buffer,0,temp);
}
//调用输入流对象的read方法，读取数据
//0,代表偏移量，如果是5，那么就从第五个读取
/* String s = new String(buffer);
//调用一个String对象的trim方法，将会去除掉这个字符串的
//首尾空格和空字符
s = s.trim();
System.out.println(s);*/
}
catch(Exception e){
System.out.println(e);
}
finally{
try{
fis.close();
fos.close();
}
catch(Exception e){
System.out.println(e);
}
}
}
}
33字符流：读写文件时，以字符为基础
字节输入流：Reader <–FileReader
int read(char[] c,int off,int len)
字节输出流：Writer <–FileWriter
void write(char[] c,int off,int len)
import java.io.*;
public class TestChar{
public static void main(String args[]){
//字符数据流 FileReader
FileReader fr = null;
FileWriter fw = null;
try{
fr = new FileReader(“e:/src/from.txt”);
fw = new FileWriter(“e:;/src/to.txt”);
char[] buffer = new char[100];
int temp = fr.read(buffer,0,buffer.length);
fw.write(buffer,0,temp);
/*for(int i = 0;i<buffer.length;i++){
System.out.println(buffer[i]);
}*/
}
catch(Exception e){
System.out.println(e);
}
finally{
try{
}
catch(Exception e){
System.out.println(e);
}
}
}
34
节点流和处理流
处理流使用实例
装饰者（Decorator）模式
节点流与处理流的关系
BufferedReader介绍
一行一行的读取
BufferedReader使用方法，生成BufferedReader对象的方法
BufferedReader in = new BufferedReader(new FileReader(“foo.in”));
处理流，Reader,Writer以及他们所有的子类都属于字符流
BufferedReader属于字符流，处理流，然后呢，它又是处理流
全称：字符输入处理流
public String readLine()
throws IOException
import java.io.*;
class Test{
public static void main(String args[]){
FileReader fileReader = null;
BufferReader bufferReader = null;
try{
fileReader = new FileReader(“e:/src/users.txt”);
bufferedReader = new BufferedReader(fileReader);
String line = null;
while(true){
line = bufferedReader.readLine();
if(line == null){
break;
}
System.out.println(line);
}
/*String line = bufferedReader.readLine();
System.out.println(line);*/
}
catch(Exception e){
System.out.println(e);
}
finally{
try{
bufferedReader.close();
fileReader.close();
}
catch(Exception e){
System.out.println(e);
}
}
}
}
装饰者模式
worker.java
interface worker{
public void doSomeWork();
}
class Plumber implements Worker{
public void doSomeWork(){
System.out.println(“修水管”);
}
}
class Carpenter implemments Worker{
public void doSomeWork(){
System.out.println(“修门窗”);
}
}
class AWorker implements Worker{
private Worker worker;
public AWorker(Worker worker){
this.worker = worker;
}
public void doSomeWork(){
System.out.println(“你好”);
worker.doSomeWork();
}
}
class Test01{
public static void main(String args[]){
//生成一个A公司水管工对象
Plumber plumber = new Plumber();
AWorker aWorker = new AWorker(plumber);
aWorker.doSomeWork();
Carpenter carpenter = new Carpenter();
AWorker aWorker2 = new AWorker(capenter);
aWorker2.doSomeWork();
}
}
35内部类和匿名内部类
什么是内部类？
内部类的使用方法
匿名内部类的使用方法
class A{
class B{
}
}
如何生成内部类的对象？
class Test{
public static void mian(String args[]){
A a = new A();
A.B b = a.new B();
}
}
class A{
int i;
class B{
int j;
int funB(){
int result = i + j;
return result;
}
}
}
class Test{
public static void main(String args[]){
A a = new A();
A.B b = a.new B();
a.i = 3;
b.j = 1;
int result = b.funB();
System.out.println(result);
}
}
class A{
int i;
class B{
int j;
int funB(){
int result = A.this.i + this.j;
return result;
}
}
}
匿名内部类
interface A{
public void doSomething();
}
class B{
public void fun(A a){
System.out.println(“B类的fun函数”);
a.doSomething();
}
}
class AImpl implements A{
public void doSomething(){
System.out.println(“doSomething”);
}
}
class Test{
public static void main(String args[]){
AImpl al = new AImpl();
A a = al;
B b = new B();
b.fun(a);
}
}
匿名内部类
class Test{
public static void main(String args[]){
//AImpl al = new AImpl();
///A a = al;
B b = new B();
b.fun(new A(){
public void doSomething(){
System.out.println(“匿名内部类”);
}
});
}
}
36Java当中的线程
1.进程和线程
2.多线程程序运行模式
3.定义线程的方法
多线程与多进程
多进程：
在操作系统中能（同时）运行多个任务（程序）
多线程：
在同一应用程序中多个顺序流（同时）执行
创建线程的方法
方法1：
定义一个线程类，它继承类Thread并重写其中的方法run();方法run()称为线程体；由于Java只支持单继承，用这种方法定义的类不能再继承其他类。
FirstThread.java
class FirstThread extends Thread{
public void run(){
for(int i=0;i<100;i++){
System.out.println(“FirstThread”+i);
}
}
}
class Test{
public static void main(String args[]){
//生成线程类的对象
FirstThread ft = new FirstThread();
//启动线程
ft.start();
//ft.run(); 千万不能这样写
for(int i = 0;i<100;i++){
System.out.println(“main”+i);
}
}
}
37
实现线程的第二种方法
控制线程的常用函数
方法二：提供一个实现接口Runnable的类作为线程的目标对象，在初始化一个Thread类或者Thread子类的线程对象时，把目标对象传递给这个线程实例，由该目标对象提供线程体。
class RunnableImpl implements Runable{
public void run(){
for(int i = 0;i<100;i++){
System.out.println(“Runnable–>”+i);
}
}
}
class Test{
public static void main(String args[]){
//生成一个Runnable接口实现类的对象
//ri 代表的是线程体
RunnableImpl ri = new RunnableImpl();
//生成一个Thread对象，并将Runnable接口实现类的对象作为参数
//传递给该Thread对象
//代表的是线程
Thread t = new Thread(ri);
System.out.println(t.getPriority());
//通知Thread对象，执行start方法
t.start();
}
}
线程的简单控制方法
中断线程
Thread.sleep();
Thread.yield();//让出自己正在使用的CPU
设置线程的优先级
getPriority();
setPriority();
class RunnableImpl implements Runnable{
public void run(){
for(int i=0;i<100;i++){
System.out.println(“Runnable–>”+i);
if(i==50){
try{
Thread.sleep(2000);
}
catch(Exception e){
System.out.println(e);
}
}
}
}
}
class Test{
public static void main(String args[]){
//生成一个Runnable接口实现类的对象
RunnableImpl ri = new RunnableImpl();
//生成一个Thread对象，并将Runnable接口实现类的对象作为参数
//传递给该Thread对象
Thread t = new Thread(ri);
//线程的优先级最大是10，最小是1，可以使用Thread所提供的静态常理来设置线程的优先级
t.setPriority(Thread.MAX_PRIORITY);
//t.setPriority(Thread.MIN_PRIORITY);
//通知Thread对象，执行start方法
t.start();
System.out.println(t.getPriority());
}
}
38
多线程数据安全
同步线程的方法
class Test{
public static void main(String args[]){
MyThread myThread = new MyThread();
//生成两个Thread对象，但是这两个Thread对象共用同一个线程体
Thread t1 = new Thread(myThread);
Thread t2 = new Thread(myThread);
//每一个线程都有名字，可以通过Thread对象的setName()方法设置线程名字，也可以使用getName方法获取线程的名字
t1.setName(“线程a”);
t2.setName(“线程b”);
//分别启动两个线程
t1.start();
t2.start();
}
}
class MyThread implements Runnable{
int i = 100;
public void run(){
while(true){
System.out.println(Thread.currentThread().getName()+i);
i–;
Thread.yield();
if(i<0){
break;
}
}
}
}
//同步代码块
class MyThread implements Runnable{
int i = 100;
public void run(){
while(true){
synchronized(this){
//Thread.currentThread();
System.out.println(Thread.currentThread().getName()+i);
i–;
Thread.yield();
if(i<0){
break;
}
}
}
}
}
39深入同步语法
深入synchronized关键字
class Service{
public void fun1(){
synchronized(this){
try{
Thread.sleep(3*1000);
}
catch(Exception e){
System.out.println(e);
}
System.out.println(“fun1”);
}
}
public void fun2(){
synchronized(this){
System.out.println(“fun2”);
}
}
}
class MyThread1 implements Runnable{
private Service service;
public MyThread1(Service service){
this.service = service;
}
public void run(){
service.fun1();
}
}
class MyThread2 implements Runnable{
private Service service;
public MyThread2(Service service){
this.service = service;
}
public void run(){
service.fun2();
}
}
class Test{
public static void main(String args[]){
Service service = new Service();
Thread t1 = new Thread(new MyThread1(service));
Thread t2 = new Thread(new MyThread2(service));
t1.start();
t2.start();
}
}
同步锁 锁住的是service
同步方法,同步代码块锁住this
class Service{
public synchronized void fun1(){
try{
Thread.sleep(3*1000);
}
catch(Exception e){
System.out.println(e);
}
System.out.println(“fun1”);
}
public void fun2(){
synchronized(this){
System.out.println(“fun2”);
}
}
}
40JAVA当中的数组
数组的类型
数组的定义方法
数组的操作方法
class Test{
public static void main(String args[]){
//数组的静态声明
int arr [] = {5,2,7,8,9,0};
arr[3] = 10;
//System.out.println(arr[3]);
for(int i = 0;i<5;i++){
System.out.println(arr[i]);
}
}
}
class Test{
public static void main(String args[]){
int arr[] = {2,4,6,7,8};
System.out.println(arr.length);
}
}
数组的动态声明
class Test{
public static void main(String args[]){
//动态声明
int arr [] = new int [10];
System.out.println(“arr数组长度”+arr.length);
for(int i = 0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
二维数组定义方法
class Test{
public static void main(String args[]){
//二维数组的定义方法，长度为3
int arr [][] = {
{1,2,3},{4,5,6},{7,8,9}}；
System.out.println(arr[1][1]);
for(int i = 0; i < 3; i++){
for(int j = 0; j < 3; j++){
System.out.println(arr[i][j]);
}
}
}
}
优化
class Test{
public static void main(String args[]){
//二维数组的定义方法，长度为3
int arr [][] = {
{1,2,3},{4,5,6},{7,8}}；
System.out.println(arr[1][1]);
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.println(arr[i][j]);
}
}
}
}
动态
class Test{
public static void main(String args[]){
//int arr [][] = {
{1,2,3},{4,5,6},{7,8}}；
int arr [][] = new int[3][5];
System.out.println(arr[1][1]);
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.println(arr[i][j]);
}
}
}
}
41类集框架
什么是类集框架
集合的种类
类集框架的基础结构
什么是类集框架
1.类集框架是一组类和接口；
2.位于java.util包当中；
3.主要用户存储和管理对象；
4.主要分为三大类—集合，列表和映射
什么是集合（Set）
集合中的对象不按特定的方式排序，并且没有重复对象；
对象是没有顺序的，集合是没有顺序的
什么是列表（List）
集合中对象按照索引位置排序，可以有重复的对象。
可以按照顺序取，也可以指定取。
什么是映射（Map）
集合中的每一个元素包含一个键对象和一个值对象，键不可以重复，值可以重复。
数据结构 键值对
类集框架主体结构
interface
Iterator Collection
ListIterator List Set Map
LinkeList ArrayList HashSet SortedSet HashMap SortedMap
LinkedHashSet TreeSet LinkedHashMap TreeMap
Comparable Comparator Collections Arrays
//arrayList默认10,可无限长，关于泛型
Test.java
import java.util.List;
import java.util.ArrayList;
public class Test{
public static void main(String args[]){
//ArrayList arrayList = new ArrayList();
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add(“a”);
arrayList.add(“b”);
arrayList.add(“c”);
//String s = arrayList.get(1);
//System.out.println(s);
for(int i=0;i<3;i++){
String s = arrayList.get(i);
System.out.println(s);
}
}
}
优化
import java.util.List;
import java.util.ArrayList;
public class Test{
public static void main(String args[]){
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("a");
arrayList.add("b");
arrayList.add("c");
arrayList.add("d");
for(int i = 0; i < arrayList.size(); i++){
String s = arrayList.get(i);
}
}
}import java.util.List;
import java.util.ArrayList;
public class Test{
public static void main(String args[]){
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("a");
arrayList.add("b");
arrayList.add("c");
arrayList.add("d");
arrayList.remove(1);
for(int i = 0; i<arrayList.size();i++){
String s = arrayList.get(i);
System.out.println(s);
}
}
}
42
类集框架
集合 无序 不可重复
列表 有序 可重复
映射
Collection和Iterator接口
Set与HashSet的使用方法
Collection 接口（一）
boolean add(Object o) 向集合当中加入一个对象
void clear() 删除集合当中的所有对象
boolean isEmpty() 判断集合是否为空
remove(Object o) 从集合中删除一个对象的引用
int size() 返回集合中元素的数目
Set继承了Collection
import java.util.Set;
import java.util.HashSet;
public class Test{
public static void main(String args[]){
//HashSet<String> hashSet = new HashSet<String>();
//Set<String> set = new HashSet<String>();
//别管就是转，方便
Set<String> set = new HashSet<String>();
set.add("a");
set.add("b");
set.add("c");
set.add("d");
int i = set.size();
System.out.println(i);
}
}
不可以重复
import java.util.Set;
import java.util.HashSet;
public class Test{
public static void main(String args[]){
//HashSet<String> hashSet = new HashSet<String>();
//Set<String> set = new HashSet<String>();
//别管就是转，方便
Set<String> set = new HashSet<String>();
boolean b1 = set.isEmpty();
System.out.println(b1);
set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("c");
boolean b2 = set.isEmpty();
System.out.println(b2);
int i = set.size();
System.out.println("clear之前的长度"+i);
set.clear();
int j = set.size();
System.out.println(j);
}
}取数据，迭代 iterate器 (Iterator)
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
public class Test{
public static void main(String args[]){
//HashSet<String> hashSet = new HashSet<String>();
//Set<String> set = hashSet;
//Iterator <-- Collection <-- Set <-- HashSet
//hasNext() next()
Set<String> set = new HashSet<String>();
set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("c");
//生成迭代器对象
//调用Set对象的Iterator方法，会生成一个迭代器对象，该对象用于遍历整个Set
Iterator<String> it = set.iterator();
boolean b1 = it.hasNext();
if(b1){
String s = it.next();
System.out.println(s);
}
boolean b2 = it.hasNext();
if(b2){
String s = it.next();
System.out.println(s);
}
}
}
迭代器的使用
it.hasNext();
还有没有下一个元素，如果这个游标后面有元素就返回true，否则,false;
it.next();
返回游标所指位置的下一个元素，取出，用hasNext()看有没有，next取
ok
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
public class Test{
public static void main(String args[]){
//HashSet<String> hashSet = new HashSet<String>();
//Set<String> set = hashSet;
//Iterator <-- Collection <-- Set <-- HashSet
// <--List <--ArrayList
//has Next() next()
Set<String> set = new HashSet<String>();
set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("c");
Iterator<String> it = set.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
} 43Map
Map与HashMap的使用方法
JDK帮助文档
什么是映射（Map）
映射中的每一个元素包含一个键对象和一个值对象，键不可以重复，值可以重复。
Map存的是一对
import java.util.Map;
import java.util.HashMap;
public class Test{
public static void main(String args[]){
HashMap<String,String> hasMap = new HashMap<String,String>()；
Map<String,String> map = hasMap;
map.put("1","a");
map.put("2","b");
map.put("3","c");
map.put("4","d");
int i = map.size();
System.out.println(i);
}
}import java.util.Map;
import java.util.HashMap;
public class Test{
public static void main(String args[]){
HashMap<String,String> hashMap = new HashMap<String,String>();
Map<String,String> map = hashMap;
map.put("1","a");
map.put("2","b");
map.put("3","c");
map.put("4","d");
map.put("3","e");
String s = map.get("3");
System.out.println(s);
}
}import java.util.Map;
import java.util.HashMap;
public class Test{
public static void main(String args[]){
HashMap<String,String> hashMap = new HashMap<String,String>();
Map<String,String> map = hashMap;
map.put("1","a");
map.put("2","b");
map.put("3","c");
map.put("4","d");
map.put("3","e");
int i = map.size();
System.out.println(i);
String s = map.get("3");
System.out.println(s);
}
}
从入门到熟悉！
坚决不放弃！
喜欢本文的朋友们
欢迎长按下图关注订阅号
醉翁猫咪
收看更多精彩内容
