zoukankan      html  css  js  c++  java
  • Java复习笔记

    一、面向对象

    1.面向对象三个主要特征

    封装

    • 两个含义:把一个对象的属性和方法看成一个密不可分的整体,将两者封装成一个不可分割的独立单位(对象)中;隐藏一些外界不需要的属性和方法。

    继承

    • 作用:提高开发效率,减少重复代码;反映事物一般特性的类(主类),在此基础上派生出的特殊事物的类(父类);

    多态

    • 方法重载:方法名称相同,参数不同;对象多态:子类对象与父类对象的相互转换。作用:使得程序抽象程度与简洁程度越高,利于分组协同开发。

    2.Java主要的四个内存空间

    • 堆内存空间:保存对象的真正数据,每个对象的属性的内容。
    • 栈内存空间:保存的对象对应的堆内存的空间地址。
    • 全局数据区:保存static类型的属性内容。
    • 全局代码区:保存所有的方法定义。

    3.String类的主要方法

    • charAt(i):取得字符串索引位置字符
    • toCharArray():字符串转换为字符数组
    • equals():字符串内容比较
    • replaceAll("1","2"):将字符串中所有1替换为2
    • substring():字符串截取
    • split():字符串拆分

    4.this关键字

    本类属性

    • 为了让属性看起来有意义,用this.属性来表示本类当中的属性

    本类方法

    • this(参数),代用本类中的构造方法,实现构造方法之间的互相调用,可以减少重复代码,一般放在构造方法的首行

    当前对象

    • this代表了正在调用类中方法的对象,所有的当前对象都用this表示

    5.static关键字

    • 定义属性:使用static定义公共属性(所有对象都可使用),修改的属性内容适用于全部的实例化对象,可直接通过类名称.static属性来进行调用修改
    • 定义方法:static定义的方法,类名称直接调用
    • 作用:没有实例化对象时执行类的某些操作;实现数据的共享
    • 应用:实例化对象个数统计、类属性自动命名等

    6.代码块

    • 普通代码块:方法中的代码块
    • 构造块:类中的代码块,单独的{}中的代码,构造块优先于构造方法执行,每次实例化对象都会执行。
    • 静态块:(非主类中)静态块优先于构造块执行,不管有多少实例化对象,只执行一次。(主类中)主类中的静态块优先于主方法执行。

    7.类分析

    使用类实现简单登录,分析类,主方法只关注结果,验证功能交由其他类完成

    import java.util.Scanner;
    
    //登录验证
    class LoginValidate {
    	private String username;
    	private String pwd;
    
    	public LoginValidate(String username, String pwd) {
    		this.username = username;
    		this.pwd = pwd;
    	}
    
    	public boolean isValidate() {
    		if (username.equals("zq") && pwd.equals("123")) {
    			return true;
    		} else {
    			return false;
    		}
    	}
    }
    
    // 数据验证
    class Operate {
    	private String username;
    	private String pwd;
    
    	public Operate(String username, String pwd) {
    		this.username = username;
    		this.pwd = pwd;
    		this.exit();
    	}
    
    	public void exit() {
    		if (username.equals("") || pwd.equals("")) {
    			System.out.println("输入数据错误!");
    			System.exit(1);
    		}
    	}
    
    	public void getInfo() {
    		if (new LoginValidate(username, pwd).isValidate()) {
    			System.out.println("登录成功!");
    		} else {
    			System.out.println("登录失败!");
    		}
    	}
    }
    
    // 主程序,只关心结果
    public class 登录类分析 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		System.out.print("请输入用户名:");
    		String username = sc.nextLine();
    		System.out.print("请输入密码:");
    		String pwd = sc.nextLine();
    		Operate op = new Operate(username, pwd);
    		op.getInfo();
    	}
    }
    
    

    8.内部类实现链表数据结构

    待完成!

    9.继承的局限

    • 一个子类只能继承一个父类,即不允许多重继承,但允许多层继承。
    • 父类的私有属性能被继承下来,但无法直接使用,可通过get,set方法使用。
    • 继承关系中,如果实例化子类对象,,会默认先调用父类的构造方法。

    10.覆写与重载

    • 构造方法不能被继承但能被重载

    11.final关键字

    相当于一个终结器

    • 定义类:不能被继承
    • 定义方法:不能被子类覆写
    • 定义变量:相当于常量,无法被修改,且常量单词字母全部大写

    12.单例设计模式

    • 特点:构造方法被私有化,只能有一个实例化对象,通过static 在类中实例化,外部无法实例化对象
    • 应用:如Windows系统的回收站
    class Singleton {
    	private static final Singleton instance = new Singleton();
    
    	private Singleton() {
    	}
    
    	public static Singleton getInstance() {
    		return instance;
    	}
    
    	public void print() {
    		System.out.println("单例设计模式");
    	}
    }
    
    public class 单例设计模式 {
    	public static void main(String[] args) {
    		// Singleton singleton = new Singleton(); //报错,外部无法实例化对象
    		Singleton inst = null;
    		inst = Singleton.getInstance();
    		inst.print();
    	}
    }
    
    

    13.多例设计模式

    • 对象是有限个,和单例模式差不多,都是通过构造方法私有化,控制对象的个数
    • 如男女(两个对象),星期(七个对象)

    14.抽象类与模板设计模式

    • 包含抽象方法,抽象方法只声明未实现,abstract
    • 抽象类必须有子类,一个子类只能继承一个抽象类
    • 子类必须覆写抽象类中的全部抽象方法
    • 抽象类对象使用对象向上转型的方式,通过子类实例化操作

    模板设计模式

    • 抽象类:定义一个模板
    • 在Servlet中应用
    abstract class Action { // 定义模板
       public static final int EAT = 1;
       public static final int SLEEP = 3;
       public static final int WORK = 5;
       public static final int RUN = 7;
    
       public void order(int flag) {
       	switch (flag) {
       	case EAT:
       		this.eat();
       		break;
       	case SLEEP:
       		this.sleep();
       		break;
       	case WORK:
       		this.work();
       		break;
       	case RUN:
       		this.run();
       		break;
       	case EAT + SLEEP + RUN:
       		this.eat();
       		this.sleep();
       		this.run();
       		break;
       	case EAT + WORK:
       		this.eat();
       		this.work();
       		break;
       	case EAT + SLEEP + WORK + RUN:
       		this.eat();
       		this.sleep();
       		this.work();
       		this.run();
       		break;
       	}
    
       }
    
       public abstract void eat();
       public abstract void sleep();
       public abstract void work();
       public abstract void run();
    }
    
    class Dog extends Action {
    
       @Override
       public void eat() {
       	System.out.println("狗在吃");
       }
    
       @Override
       public void sleep() {
       	System.out.println("狗在睡");
       }
    
       @Override
       public void work() {
       }
    
       @Override
       public void run() {
       	System.out.println("狗在跑");
       }
    
    }
    
    public class 模板设计模式 {
       public static void main(String[] args) {
       	Action ac1 = new Dog();
       	ac1.order(Action.EAT + Action.SLEEP + Action.RUN);
       }
    }
    
    

    15.接口与工厂设计模式、代理设计模式

    • 接口implements实现对象向上转型进行接口对象的实例化
    • 多重继承;先继承后实现

    工厂设计模式

    • 实现程序的可移植性
    • 设置过渡端,,降低耦合
    interface Fruit {
    	public void eat();
    }
    
    class Apple implements Fruit {
    	public void eat() {
    		System.out.println("吃苹果");
    	}
    }
    
    class Orange implements Fruit {
    	public void eat() {
    		System.out.println("吃橘子");
    	}
    }
    
    class Factory { // 过渡端
    	public static Fruit getInstance(String className) {
    		if (className.equals("apple")) {
    			return new Apple();
    		}
    		if (className.equals("orange")) {
    			return new Orange();
    		}
    		return null;
    	}
    }
    
    public class 工厂设计模式 {
    	public static void main(String[] args) {
    		Fruit f = Factory.getInstance("apple");
    		f.eat();
    	}
    }
    
    

    代理设计模式

    • 是指一个代理主题来操作真实主题。真实主题执行具体的业务操作,而代理主题负责其他相关业务处理
    interface Network {
    	public void browse();
    }
    
    class Real implements Network {
    	public void browse() {
    		System.out.println("上网浏览信息");
    	}
    }
    
    class Proxy implements Network {
    	private Network network;
    
    	public Proxy(Network network) {
    		this.network = network;
    	}
    
    	public void check() {
    		System.out.println("检查用户是否合法");
    	}
    
    	public void browse() {
    		this.check();
    		this.network.browse();
    	}
    }
    
    public class 代理设计模式 {
    	public static void main(String[] args) {
    		Network net = new Proxy(new Real());
    		net.browse();
    	}
    }
    

    16.Object类

    • 所有类的父类
    • toString():对象地址
    • equals():比较两个对象的内存地址数值
    • 可以接收所有的引用数据类型

    17.数据转换

    • 字符串转换为基本数据类型:Integer.parseInt()、Double.paraseDouble()、Boolean.paraseBoolean()
    • int转换为String:String.valueOf()

    18.Java异常处理流程

    throw与throws的区别

    • 都是异常处理中的关键字
    • throw:用户手工抛出异常类的实例化对象
    • throws:表示方法不处理异常,而将异常交给程序被调用处处理

    19.泛型

    • 类中的属性或方法的参数类型不在定义时声明,而是在使用时动态设置
    • 泛型只能设置为类

    坐标泛型类

    class Point<T> {
    	private T x;
    	private T y;
    
    	public T getX() {
    		return x;
    	}
    
    	public void setX(T x) {
    		this.x = x;
    	}
    
    	public T getY() {
    		return y;
    	}
    
    	public void setY(T y) {
    		this.y = y;
    	}
    
    }
    
    public class 泛型 {
    	public static void main(String[] args) {
    		Point<String> point = new Point<String>();
    		point.setX("东经100度");
    		point.setY("西经200度");
    		System.out.println(point.getX() + "," + point.getY());
    	}
    }
    
    

    20.枚举

    应用

    enum Sex {
    	MALE, FEMALE;
    	private String title;
    
    	public String getTitle() {
    		return title;
    	}
    
    	public void setTitle(String title) {
    		this.title = title;
    	}
    }
    
    class Person {
    	private String name;
    	private int age;
    	private Sex sex;
    
    	public Person(String name, int age, Sex sex) {
    		this.name = name;
    		this.age = age;
    		this.sex = sex;
    	}
    
    	@Override
    	public String toString() {
    		return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
    	}
    
    }
    
    public class 枚举 {
    	public static void main(String[] args) {
    		Person per = new Person("张三", 20, Sex.MALE);
    		System.out.println(per.toString());
    	}
    }
    
    

    二、JavaSE

    1.进程与线程

    • 进程:程序的一次动态执行过程,经历了程序加载、执行、执行完毕的完整过程,每一个进程至少有两个线程,main和gc
    • 线程:线程是进程的进一步划分,一个进程中有很多线程,线程依附于进程才能够存在,主方法是一个线程
    • java支持多线程

    2.多线程的实现

    • 继承Thread类:覆写run()方法,启动start()方法
    class MyThread extends Thread {
    	private String title;
    
    	public MyThread(String title) {
    		this.title = title;
    	}
    
    	@Override
    	public void run() {
    		for (int i = 0; i < 3; i++) {
    			System.out.println(this.title + "运行,x=" + i);
    		}
    	}
    }
    
    public class 多线程 {
    	public static void main(String[] args) {
    		MyThread th1 = new MyThread("线程A");
    		MyThread th2 = new MyThread("线程B");
    		MyThread th3 = new MyThread("线程C");
    		th1.start();
    		th2.start();
    		th3.start();
    	}
    }
    
    
    • 实现Runnable接口:避免单继承局限,但仍然需要Thread来启动
    class MyThread implements Runnable {
    	private String title;
    
    	public MyThread(String title) {
    		this.title = title;
    	}
    
    	@Override
    	public void run() {
    		for (int i = 0; i < 3; i++) {
    			System.out.println(this.title + "运行,x=" + i);
    		}
    	}
    }
    
    public class 多线程 {
    	public static void main(String[] args) {
    		MyThread th1 = new MyThread("线程A");
    		MyThread th2 = new MyThread("线程B");
    		MyThread th3 = new MyThread("线程C");
    		new Thread(th1).start();
    		new Thread(th2).start();
    		new Thread(th3).start();
    	}
    }
    
    
    • 多线程卖票程序
    class MyThread implements Runnable {
    	private int ticket = 5; // 5张票
    
    	@Override
    	public void run() {
    		for (int i = 0; i < 50; i++) {
    			if (this.ticket > 0) {
    				System.out.println("卖票,ticket = " + this.ticket--);
    			}
    
    		}
    	}
    }
    
    public class 多线程 {
    	public static void main(String[] args) {
    		MyThread th = new MyThread();
    		new Thread(th).start();
    		new Thread(th).start();
    		new Thread(th).start();
    	}
    }
    
    

    3.同步与死锁

    • 同步:多个线程操作同一资源,解决安全性问题,是指多个操作在同一时间段内只能有一个线程进行,其他线程要等待此线程完成后才可以继续执行
    • 方式一:同步代码块
    class MyThread1 implements Runnable{
    	private int ticket = 6;
    	@Override
    	public void run(){
    		for(int i =0;i<10;i++){
    			synchronized (this) { //同步代码块
    				if(this.ticket>0){
    					try{
    						Thread.sleep(100);
    					}catch(InterruptedException e){
    						e.printStackTrace();
    					}
    					System.out.println(Thread.currentThread().getName()+"卖票,ticket="+this.ticket--);
    				}
    			}
    		}
    	}
    }
    public class 同步 {
    	public static void main(String[] args) {
    		MyThread1 mt = new MyThread1();
    		new Thread(mt,"票贩子A").start();
    		new Thread(mt,"票贩子B").start();
    		new Thread(mt,"票贩子C").start();
    		new Thread(mt,"票贩子D").start();
    		new Thread(mt,"票贩子E").start();
    	}
    }
    
    
    • 方式二:同步方法
    class MyThread1 implements Runnable {
    	private int ticket = 6;
    
    	@Override
    	public void run() {
    		for (int i = 0; i < 10; i++) {
    			this.sale();
    		}
    	}
    
    	public synchronized void sale() { // 同步方法
    		if (this.ticket > 0) {
    			try {
    				Thread.sleep(100);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			System.out.println(Thread.currentThread().getName() + "卖票,ticket="
    					+ this.ticket--);
    		}
    	}
    }
    
    public class 同步 {
    	public static void main(String[] args) {
    		MyThread1 mt = new MyThread1();
    		new Thread(mt, "票贩子A").start();
    		new Thread(mt, "票贩子B").start();
    		new Thread(mt, "票贩子C").start();
    		new Thread(mt, "票贩子D").start();
    		new Thread(mt, "票贩子E").start();
    	}
    }
    
    
    • 死锁:两个线程都在等待彼此先完成,造成了程序的停滞状态

    生产者消费者问题

    • 解决数据错位
    • 解决数据重复生产和重复取出
    class Message {
    	private String title;
    	private String content;
    	private boolean flag = true;
    
    	// flag == true:没有数据,可生产,但是不能取出
    	// flag == false:有数据,可以取出,但是不能生产
    	public synchronized void set(String title, String content) { // 生产判断
    		if (this.flag == false) {
    			try {
    				super.wait();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		this.title = title;
    		this.content = content;
    		try {
    			Thread.sleep(200);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		this.content = content;
    		this.flag = false;
    		super.notify(); // 可以唤醒wait()
    	}
    
    	public synchronized void get() { // 取出判断
    		if (this.flag == true) {
    			try {
    				super.wait();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    		System.out.println(this.title + "-->" + this.content);// 取走数据
    		this.flag = true;
    		super.notify();
    	}
    
    	public String getTitle() {
    		return title;
    	}
    
    	public void setTitle(String title) {
    		this.title = title;
    	}
    
    	public String getContent() {
    		return content;
    	}
    
    	public void setContent(String content) {
    		this.content = content;
    	}
    
    	public boolean isFlag() {
    		return flag;
    	}
    
    	public void setFlag(boolean flag) {
    		this.flag = flag;
    	}
    
    }
    
    // 生产者
    class Producer implements Runnable {
    	private Message msg = null;
    
    	public Producer(Message msg) {
    		this.msg = msg;
    	}
    
    	@Override
    	public void run() {
    		for (int i = 0; i < 50; i++) {
    			if (i % 2 == 0) {
    				this.msg.set("标题1", "内容1");
    			} else {
    				this.msg.set("标题2", "内容2");
    			}
    		}
    	}
    }
    
    // 消费者
    class Consumer implements Runnable {
    	private Message msg = null;
    
    	public Consumer(Message msg) {
    		this.msg = msg;
    	}
    
    	@Override
    	public void run() {
    		for (int i = 0; i < 50; i++) {
    			this.msg.get();
    		}
    	}
    }
    
    public class 生产者消费者问题 {
    	public static void main(String[] args) {
    		Message msg = new Message();
    		new Thread(new Producer(msg)).start();
    		new Thread(new Consumer(msg)).start();
    	}
    }
    

    三、常用类库

    1.StringBuffer类

    • 适用于字符串要频繁修改
    • append():拼接
    • reverse():反转
    • replace(int start,int end,String str):替换
    • insert(int offset,数据):插入
    • delete(start,end):删除

    2.System类

    • arraycooy(原数组,原数组开始点,目标数组,目标数组开始点,长度):数组拷贝
    • currentTimeMillis():可用来统计运行时间

    3.日期操作类

    • getTime():将Data变为long
    • SimpleDataFormat():SimpleDataFormat sdf = new SimpleDataFormat("yyyy-MM-dd HH:mm:ss SSS");String str = sdf.format(data);

    4.随机数类Random

    • nextInt(101):0-100的随机数

    5.Math类

    • round():四舍五入

    6.Array数组操作类

    • equals(int[] a,int[] b):相等判断
    • fill(int[] a,int val):指定内容填充
    • sort(int[] a):排序
    • binarySearch(int[] a,int key):二分查找
    • toString(int[] a):输出数组信息

    7.比较器

    • 用作对象的比较排序:如根据年龄对人排序
    import java.util.*;
    
    class Person1 implements Comparable<Person1> {
    	private String name;
    	private int age;
    
    	public Person1(String name, int age) {
    		this.name = name;
    		this.age = age;
    	}
    
    	@Override
    	public String toString() {
    		return "Person1 [name=" + name + ", age=" + age + "]";
    	}
    
    	@Override
    	public int compareTo(Person1 o) {
    		if (this.age > o.age) {
    			return 1;
    		} else if (this.age < o.age) {
    			return -1;
    		} else {
    			return 0;
    		}
    	}
    
    }
    
    public class 比较器 {
    	public static void main(String[] args) {
    		Person1 per[] = new Person1[] { new Person1("张三", 19),
    				new Person1("李四", 18), new Person1("王五", 20) };
    		Arrays.sort(per);
    		System.out.println(Arrays.toString(per));
    	}
    }
    
    

    8.正则表达式

    • matches(String regex):正则匹配
    • replaceAll(String regex,String replacement):替换所有
    • replaceFrist(String regex,String replacement):替换首个
    • split(String regex):正则拆分

    四、Java IO

    1.列出指定目录下的全部内容

    import java.io.File;
    
    public class 文件夹 {
    	public static void main(String[] args) {
    		File file = new File("D:" + File.separator + "桌面");
    		print(file);
    	}
    
    	public static void print(File file) {
    		if (file.isDirectory()) {
    			File result[] = file.listFiles();
    			if (result != null) {
    				for (int i = 0; i < result.length; i++) {
    					print(result[i]);//递归打印
    				}
    			}
    			System.out.println(file);
    		}
    	}
    }
    
    

    2.字节输出流

    • 输出内容到文件
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.OutputStream;
    
    public class 字节输入流 {
    	public static void main(String[] args) throws Exception {
    		File file = new File("D:" + File.separator + "桌面" + File.separator
    				+ "java.txt");
    		if (!file.getParentFile().exists()) {// 没有文件夹,就创建
    			file.getParentFile().mkdirs();
    		}
    		OutputStream output = new FileOutputStream(file, true);// true表示追加数据
    		String data = "Hello Java .
    ";
    		// output.write(data.getBytes(),0,5); //0,5表示指定字符串
    		output.write(data.getBytes());
    		output.close();
    	}
    }
    
    

    3.字节输入流

    • 读取数据
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.InputStream;
    
    
    public class 字节输入流 {
    	public static void main(String[] args) throws Exception {
    		File file = new File("D:"+File.separator+"桌面"+File.separator+"java.txt");
    		if(file.exists()){
    			InputStream input = new FileInputStream(file);
    			byte data[] = new byte[1024];
    			int len = input.read(data);//字节数
    			System.out.println(len);
    			input.close();
    			System.out.println("读取的数据为:"+new String(data,0,len));
    		}
    	}
    }
    
    

    4.字符输出流

    public static void main(String[] args) throws Exception {
    		File file = new File("D:" + File.separator + "桌面" + File.separator
    				+ "java.txt");
    		if (!file.getParentFile().exists()) {
    			file.getParentFile().mkdirs();
    		}
    		Writer out = new FileWriter(file);
    		String data = "Hello Java .
    ";
    		out.write(data);
    		out.close();
    	}
    

    5.字符输入流

    public static void main(String[] args) throws Exception {
    		File file = new File("D:"+File.separator+"桌面"+File.separator+"java.txt");
    		if(file.exists()){
    			Reader in = new FileReader(file);
    			char data[] = new char[1024];
    			int len = in.read(data);//字节数
    			System.out.println(len);
    			in.close();
    			System.out.println("读取的数据为:"+new String(data,0,len));
    		}
    	}
    

    6.字节流与字符流的区别

    • 字节流:直接操作的是数据终端,如文件;
    • 字符流:操作的是缓冲区,由缓冲区去输出内容,最后需要关闭或者刷新,不然不能真正输出内容到文件;处理中文用字符流会更好

    7.内存操作流

    • 以内存作为操作的终端,不产生临时文件
    import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    public class 内存操作流 {
    	public static void main(String[] args) throws Exception {
    		String str = "hello world.";
    		OutputStream output = new ByteArrayOutputStream();
    		InputStream input = new ByteArrayInputStream(str.getBytes());
    		int temp = 0;
    		while ((temp = input.read()) != -1) {
    			output.write((char) Character.toUpperCase(temp));
    		}
    		String newStr = output.toString();
    		output.close();
    		input.close();
    		System.out.println(newStr);
    	}
    }
    
    

    8.打印流

    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.PrintStream;
    
    public class 打印流 {
    	public static void main(String[] args) throws Exception {
    		PrintStream tools = new PrintStream(new FileOutputStream(new File("D:"
    				+ File.separator + "桌面" + File.separator + "java.txt")));
    		String name = "张三";
    		int age = 20;
    		double score = 99.95452;
    		tools.printf("姓名:%s,年龄:%d,成绩:%5.2f", name, age, score);
    		tools.close();
    	}
    }
    

    9.输入

    • BufferReader buf = new BufferReader(new InputStreamReader(System.in));String str = buf.readLine();
    • Scanner scan = new Scanner(System.in);scan.next();

    10.对象序列化

    • 目的:为保证对象可以以二进制数据的方式进行传输
    • 对象所在类实现java.io.Serializable接口
    • transient关键字定义的属性不被序列化
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    class Person2 implements Serializable {
    	private String name;
    	private int age;
    	private transient String pwd;
    
    	public Person2(String name, int age, String pwd) {
    		this.name = name;
    		this.age = age;
    		this.pwd = pwd;
    	}
    
    	@Override
    	public String toString() {
    		return "Person [name=" + name + ", age=" + age + ", pwd=" + pwd + "]";
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public String getPwd() {
    		return pwd;
    	}
    
    	public void setPwd(String pwd) {
    		this.pwd = pwd;
    	}
    }
    
    public class 对象序列化 {
    	public static void main(String[] args) throws Exception {
    		Person2 p = new Person2("zhangsan", 20, "asd123");
    		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
    				new File("D:" + File.separator + "桌面" + File.separator
    						+ "java.txt")));
    		oos.writeObject(p);
    		oos.close();
    		System.out.println(p.toString());
    	}
    }
    
    

    五、网络编程

    • 编写服务器端,客户端连接,发送数据给客户端

    服务端

    import java.io.IOException;
    import java.io.PrintStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    public class 服务端 {
    	public static void main(String[] args) throws Exception {
    		ServerSocket server = new ServerSocket(9999);// 开辟监听端口
    		System.out.println("服务开始启动...");
    		Socket client = server.accept();// 接收客户端连接,程序进入阻塞状态
    		PrintStream out = new PrintStream(client.getOutputStream());// 取得指定客户端的输出对象
    		out.println("连接服务器成功");
    		out.close();
    		client.close();
    		server.close();
    		System.out.println("服务器关闭...");
    	}
    }
    
    

    客户端

    import java.io.IOException;
    import java.net.Socket;
    import java.net.UnknownHostException;
    import java.util.Scanner;
    
    public class 客户端 {
    	public static void main(String[] args) throws Exception {
    		Socket client = new Socket("localhost", 9999);// 连接服务器和端口
    		Scanner scan = new Scanner(client.getInputStream());// 取得客户端输入流
    		scan.useDelimiter("
    ");
    		if (scan.hasNext()) {
    			System.out.println("服务器的回应数据:" + scan.next());
    		}
    		scan.close();
    		client.close();
    	}
    }
    
    

    六、类集框架

    1.List

    • 允许重复
    • List list = new ArrayList();
    • List list = new ArrayList();
    • add(),contains(),remove(),clear()

    2.Set

    • 不允许重复
    • Set set = new HashSet():无序存放
    • Set<String set = new TreeSet():有序存放,自动排序

    3.Iterator

    • 迭代输出
    • hasNext():判断是否有下一个值
    • next():当前元素
    • remove():移除当前元素
    public static void main(String[] args) {
    		List<String> all = new ArrayList<String>();
    		all.add("hello1");
    		all.add("hello2");
    		all.add("hello3");
    		Iterator<String> iter = all.iterator();
    		while(iter.hasNext()){
    			String str = iter.next();
    			System.out.println(str+"、");
    		}
    	}
    

    4.双向迭代

    public static void main(String[] args) {
    		List<String> all = new ArrayList<String>();
    		all.add("hello1");
    		all.add("hello2");
    		all.add("hello3");
    		ListIterator<String> iter = all.listIterator();
    		System.out.print("前-->后:");
    		while(iter.hasNext()){
    			String str = iter.next();
    			System.out.print(str+"、");
    		}
    		System.out.print("后-->前:");
    		while(iter.hasPrevious()){
    			String str = iter.previous();
    			System.out.print(str+"、");
    		}
    	}
    

    5.枚举输出

    • Enumeration
    public static void main(String[] args) {
    		Vector<String> all = new Vector<String>();
    		all.add("hello1");
    		all.add("hello2");
    		all.add("hello3");
    		Enumeration<String> enu = all.elements();
    		while(enu.hasMoreElements()){
    			String str = enu.nextElement();
    			System.out.print(str+"、");
    		}
    	}
    

    6.foreach

    • for(String str:all){}

    7.Map

    • 保存键值对,key-value,key不允许重复
    • put(key,value):保存数据
    • get(key):通过指定的key得到value
    • keySet():将map中的所有key以集合的方式返回
    • entrySet():将map变为set集合
    • 实例化:Map<Integer,String> map = new HashMap<Integer,String>();
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class 偶对象 {
    	public static void main(String[] args) {
    		Map<Integer, String> map = new HashMap<Integer, String>();
    		map.put(3, "lisi");
    		map.put(3, "zhangsan");// key重复,被覆盖
    		map.put(2, "wangwu");
    		map.put(1, "zhaoliu");
    		Set<Map.Entry<Integer, String>> set = map.entrySet();// map转换为set
    		Iterator<Map.Entry<Integer, String>> iter = set.iterator();
    		while (iter.hasNext()) {
    			Map.Entry<Integer, String> me = iter.next();
    			System.out.println(me.getKey() + "," + me.getValue());
    		}
    	}
    }
    
    

    8.栈

    • 先进后出
    import java.util.Stack;
    
    public class 栈 {
    	public static void main(String[] args) {
    		Stack<String> all = new Stack<String>();
    		all.add("A");
    		all.add("B");
    		all.add("C");
    		System.out.println(all.pop());
    		System.out.println(all.pop());
    		System.out.println(all.pop());
    		System.out.println(all.pop());// 没数据了,抛异常
    	}
    }
    
    

    七、数据库操作

    1.连接MySQL数据库

    • 需要先下载驱动,然后添加到项目中,右键项目->Build Path->Add External...->选择到自己的驱动jar
    package zq;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    
    public class 连接数据库 {
    	public static final String DBDRIVER = "com.mysql.jdbc.Driver";
    	public static final String DBURL = "jdbc:mysql://localhost:3306/java";
    	public static final String DBUSER = "root";
    	public static final String DBPWD = "ZQ123789";
    
    	public static void main(String[] args) throws Exception {
    		Connection conn = null;
    		Class.forName(DBDRIVER);// 加载驱动程序
    		conn = DriverManager.getConnection(DBURL, DBUSER, DBPWD);// 连接数据库
    		System.out.println(conn);// 输出对象则连接成功
    		conn.close();
    	}
    }
    
    

    2.Statement操作数据表

    创建数据表

    create table member(
    	mid int PRIMARY KEY,
    	name VARCHAR(20) not null,
    	age int(3),
    	birthday VARCHAR(20),
    	note VARCHAR(200),
    	CONSTRAINT age CHECK (age BETWEEN 0 and 200)
    );
    

    插入数据

    package zq;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.Statement;
    import java.util.Date;
    
    public class 连接数据库 {
    	public static final String DBDRIVER = "com.mysql.jdbc.Driver";
    	public static final String DBURL = "jdbc:mysql://localhost:3306/java";
    	public static final String DBUSER = "root";
    	public static final String DBPWD = "ZQ123789";
    
    	public static void main(String[] args) throws Exception {
    		Connection conn = null; // 每一个Connection对象表示一个数据库连接
    		Statement stmt = null; // 数据库操作对象
    		Class.forName(DBDRIVER);// 加载驱动程序
    		conn = DriverManager.getConnection(DBURL, DBUSER, DBPWD);// 连接数据库
    		stmt = conn.createStatement();// 找到Statement接口对象
    		String sql = "insert into member(mid,name,age,birthday,note) values" +
    				"(1,'张三',20,'1998-10-04','java开发工程师')";
    		int len = stmt.executeUpdate(sql);
    		System.out.println("更新行数:"+len);
    		stmt.close();
    		conn.close();
    	}
    }
    

    修改数据

    package zq;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.Statement;
    import java.util.Date;
    
    public class 连接数据库 {
    	public static final String DBDRIVER = "com.mysql.jdbc.Driver";
    	public static final String DBURL = "jdbc:mysql://localhost:3306/java";
    	public static final String DBUSER = "root";
    	public static final String DBPWD = "ZQ123789";
    
    	public static void main(String[] args) throws Exception {
    		Connection conn = null; // 每一个Connection对象表示一个数据库连接
    		Statement stmt = null; // 数据库操作对象
    		Class.forName(DBDRIVER);// 加载驱动程序
    		conn = DriverManager.getConnection(DBURL, DBUSER, DBPWD);// 连接数据库
    		stmt = conn.createStatement();// 找到Statement接口对象
    		String sql = "update member set name='李四',age=22,note='前端工程师' where mid=1" ;
    		int len = stmt.executeUpdate(sql);
    		System.out.println("更新行数:"+len);
    		stmt.close();
    		conn.close();
    	}
    }
    

    删除操作

    String sql = "delete from member where mid=1";
    

    查询数据

    package zq;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    import java.util.Date;
    
    public class 连接数据库 {
    	public static final String DBDRIVER = "com.mysql.jdbc.Driver";
    	public static final String DBURL = "jdbc:mysql://localhost:3306/java";
    	public static final String DBUSER = "root";
    	public static final String DBPWD = "ZQ123789";
    
    	public static void main(String[] args) throws Exception {
    		Connection conn = null; // 每一个Connection对象表示一个数据库连接
    		Statement stmt = null; // 数据库操作对象
    		Class.forName(DBDRIVER);// 加载驱动程序
    		conn = DriverManager.getConnection(DBURL, DBUSER, DBPWD);// 连接数据库
    		stmt = conn.createStatement();// 找到Statement接口对象
    		String sql = "select mid,name,age,birthday,note from member" ;
    		ResultSet rs = stmt.executeQuery(sql);//查询数据,返回结果集合
    		while(rs.next()){
    			int mid = rs.getInt("mid");
    			String name = rs.getString("name");//getString()可以接收任意类型的数据
    			int age = rs.getInt("age");
    			String birthday = rs.getString("birthday");
    			String note = rs.getString("note");
    			System.out.println(mid+","+name+","+age+","+birthday+","+note);
    		}
    		rs.close();
    		stmt.close();
    		conn.close();
    	}
    }
    
    

    预处理

    package zq;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.Statement;
    import java.util.Date;
    
    import com.mysql.jdbc.PreparedStatement;
    
    public class 连接数据库 {
    	public static final String DBDRIVER = "com.mysql.jdbc.Driver";
    	public static final String DBURL = "jdbc:mysql://localhost:3306/java";
    	public static final String DBUSER = "root";
    	public static final String DBPWD = "ZQ123789";
    
    	public static void main(String[] args) throws Exception {
    		Connection conn = null; // 每一个Connection对象表示一个数据库连接
    		PreparedStatement pstmt = null; // 数据库操作对象
    		Class.forName(DBDRIVER);// 加载驱动程序
    		conn = DriverManager.getConnection(DBURL, DBUSER, DBPWD);// 连接数据库
    
    		String name = "张珊";
    		int age = 18;
    		Date birthday = new Date();
    		String note = "java 开发工程师";
    		String sql = "insert into member(mid,name,age,birthday,note)values(2,?,?,?,?)";
    
    		pstmt = (PreparedStatement) conn.prepareStatement(sql);// 找到Statement接口对象
    		pstmt.setString(1, name);
    		pstmt.setInt(2, age);
    		pstmt.setDate(3, new java.sql.Date(birthday.getTime()));
    		pstmt.setString(4, note);
    
    		int len = pstmt.executeUpdate();
    		System.out.println("更新行数:" + len);
    
    		pstmt.close();
    		conn.close();
    	}
    }
    
    

    模糊查询

    String column = "name";
    String keyWord = "三";
    String sql = "select mid,name,age,birthday,note from member where"+column+"like ?";
    ......
    pstmt.setString(1,"%"+keyWord+"%");
    ResultSet rs = pstmt.executeQuery();
    
    版权声明:本文为博主原创文章,转载请附上博文链接!
  • 相关阅读:
    转: CvMat,Mat和IplImage之间的转化和拷贝
    Scrapy 轻松定制网络爬虫
    榆林暑期见习
    文学
    浅析Redis实现lock互斥访问资源
    使用Maven构建Java项目
    正则表达式
    CSS 命名规范及标题供参考与学习
    从零开始在linux下搭建wordpress博客
    python2和python3的区别
  • 原文地址:https://www.cnblogs.com/zq98/p/14088329.html
Copyright © 2011-2022 走看看