Java-基础

Java-基础-快速入门

一.java实现跨平台的原理

二.编程前须知

	public class javaStudy{
        public void main(String [] args){
            System.out.println("Hello World!");
        }
	}

• 类旁边public的作用

  • 声明了public之后该java源文件的名子必须和此时javaStudy一致
  • 建议一个类文件里面只放一个类，非要放多个，有且只有一个public
  • 该java源文件经过编译生成的字节码class文件名称就和java源文件保持一致

• public void main(String [] args)解析

三.java编程基础

1.变量

• 不能声明同名变量
• 关键字不能作为变量名
• 变量名是区分大小写的
• 变量名开头不能用数字但是其余部分可以用

2.数据类型

1. 基本类型

   1. 布尔类型
   2. 数值类型
      1. byte/short/int/long/char
      2. float/double

   2.引用类型

   1. 类
   2. 接口
   3. 数组
   4. 空类型

   3.类型转换

   4.字符编码(ASCII)

   • 进制之间的转换

     • 十进制转二进制：除2取余数

       

     • 二进制转十进制：乘2的幂数

     • 八进制、二进制转换：一位变三位、三位变一位

     • 十六进制、二进制转换：一位变四位、四位变一位

       

     • 复数二进制对应的正数取反加一

三.运算符

1.算数运算符

2.赋值运算符

3.关系运算符

4.逻辑用算符

5.位运算符

6.原码 反码 补码

7.优先级

四.java条件及循环结构

1.简单条件if语句

2.多重if、else语句

3.条件语句下switch

4.while与do while

while-有可能一次也不执行,do while 至少执行一次;但执行的次数一致；

5.for循环

表达式一二三都可以省略，表达式一省略可以放到for循环的上面，

==强调==三个都可以省略，但是括号里面的分号不可省略；

6.while与for循环的对比

7.break与continue

break终止循环，continue结束本次循环;

五.数组

1.一维数组

• 创建

  • 数据类型[] 数组名 列如: int [] a =new int[4]
  • 数组的赋值

• 初始化

  • int[] score ={66,77,88};
  • int[] score =new int[]{66,77,88};
  • 通过循环从键盘获取信息并赋值

2.线性查找法

3.二叉查找法

4.冒泡排序法

n-1 轮

n-1-i轮

package sort;
public class BubbleSort {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
			int [] array= {14,45,2,55,23,64,12};
			
			for(int i=0;i<array.length-1;i++) {
				for(int j=0;j<array.length-1-i;j++) {
					if(array[j]>array[j+1]) {
						int temp=array[j+1];
						array[j+1]=array[j];
						array[j]=temp;
					}
				}
			}
			for(int i=0;i<array.length;i++) {
				System.out.println(array[i]+" ");
			}
	}
}

5.选择排序法

package sort;
public class ChooseSort {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int [] array= {14,45,2,55,23,64,12};

		for(int i=0;i<array.length-1;i++) {
			int min=i;
			//找到本轮最小值的下标
			for(int j=i+1;j<array.length;j++) {
				if(array[min]>array[j]) {
					min=j;
				}
			}
//			判断是否交换位置
			if(i!=min) {
				int temp=array[min];
				array[min]=array[i];
				array[i]=temp;
			}		
		}
		for(int i=0;i<array.length;i++) {
			System.out.println(array[i]+" ");
		}		
	}
}

6.插入排序法

package sort;
public class InsertSort {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int [] array= {14,45,2,55,23,64,12};
	
		for(int i=1;i<array.length;i++) {
			int temp=array[i];
			int j=i;
			while(j>0&&(array[j-1]>array[j])) {
				array[j]=array[j-1];
				array[j-1]=temp;
				j--;
			}
		}
		for(int i=0;i<array.length;i++) {
			System.out.println(array[i]+" ");
		}
	}
}

7.arrays类

1.数组的拷贝
int [] a={12,33,55};
int [] a2=Arrays.copyOf(a);
2.数组拷贝的范围
int [] a3=Arrays.copyOfRange(a,2,4);
//从下标为2到4开始拷贝，拷贝的个数为2个
3.数组的比较
boolean flag=Arrays.equals(a,a2);
4.数组的填充
int [] a4=new int[];
Arrays.fill(a4,10);
5.sort //binarySearch

8.二维数组

六.对象，类

• String对象的声明

  • 
  • 
  • 

• 类的方法的定义

  • 

• 方法传递不同的数据类型会有不同的结果(传递基本数据类型,传递引用数据类型)

  • 基本数据类型

    

  • 引用数据类型

    

七.封装

1.概念

2.实现

3.uml

八.构造方法

1.介绍

2.案例

3.this的使用

this就是当前对象的引用,并且当在构造方法中调用其他的构造方法的时候，this();必须放在第一位;

4.static关键字

1.数据变成公共的数据Static关键字

静态方法中不能访问对象的属性,静态方法开始于对象的属性之前

2.static语句块

static{
    number=100;
}

5.单例模式

九.方法的重载

1.同一个类中,同名不同参的情况。

十.继承

十一.super关键字

十二.重写

十三.final

十四.object类

十五.多态

• 父类的引用变量可以引用子类对象

  • Animal dog=new Dog();

• 对象的上下转型

  • 向上转型(相对来说是比较安全的,但可能会导致子类方法的丢失.)(父类的引用变量只能调用父类含有的方法或子类重写父类的方法)
  • instanceof
    • object instanceof src
    • 判断object 是否是 src的实例,object是否指向src
    • 向下转型通用的类型装换成了具体的类型，可以调用了子类的特有的方法;

• 静态绑定与动态的绑定

  

十六.抽象类

• 模板方法模式
  • 
  • 
  • 

十七.接口

• 特点:特有的功能
• interface
• 接口中存放的是静态常量(public static final)和抽象方法
• 接口实现多态 — 动态绑定

十八.面向接口编程

当没有明显的is a 关系的时候,使用接口编程接口的引用变量指向实现类的对象

• 简单工厂模式
• 
• 

十九.策略模式

二十.内部类

1.概念

2.成员内部类

• 内部类实现了多继承

  • package innerClass;
    public class InnerMultiplyDemo {
    	public static void main(String[] args) {
    		// TODO 自动生成的方法存根
    			C c=new C();
    			c.showA();
    			c.showB();
    	}
    }
    class A{
    	public void showA() {
    		System.out.println("这是A方法!");
    	}
    }
    class B{
    	public void showB() {
    		System.out.println("这是B方法!");
    	}
    }
    class C{
    	class A1 extends A{
    		public void showA() {
    			System.out.println("这是A方法!");
    		}
    	}
    	class B1 extends B{		
    	}
    	public void showA() {
    		new A1().showA();
    	}
    	public void showB() {
    		new B1().showB();
    	}
    }
    

• 一个类继承并实现同一方法的处理可以采用内部类(建议直接改方法名来处理)

3.静态内部类

4.匿名内部类

new 出来的是父类的子类,出来的是接口的实现类.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3EsN354j-1610727644249)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\1610085248387.png)]

5.局部内部类(了解)

局部内部类只能访问其方法中的常量

https://img.rruu.net/image/6001aec2b962c

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2yY9eXoN-1610727644252)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\1610086087219.png)]

二十一.自动装箱与拆箱

https://img.rruu.net/image/6001aeddccfff

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gLBMnzGZ-1610727644254)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\1610088391635.png)]

二十二.枚举类型

预先创建几个枚举类型的对象供外部适用

二十四.String、StringBuffer、StringBuilder

1.String

String s1=“123” 与 String s2=’‘123’’ 指向的字符串池地址相同

String s1=new String(“123”) String s2=new String(“123”)指向的地址不同

String 是一个常量

2.StringBuffer—动态字符串—单线程

常用的方法

3.StringBuilder—多线程—异步操作

自己写一个程序来封装StringBuilder相关的方法

二十五.date—SimpleDateFormat

1.date

2.SimpleDateFormat

二十六.Calender

Calender虽然是一个抽象的类，但是可以是根据getInstance获得一个实例（当前是日期）对象

二十七.Math

二十八.异常

1.异常概念

2.异常的分类

3.异常捕获的机制

4.throws — throw

throws—用于方法上

throw —用于手动抛出

受查异常的必须throw 并且必须throws 且调用者catch

5.自定义异常

二十九.泛型

1.概念

2.类型参数化

3.泛型类的参数可以是另外一个泛型类

package GenericClass;
public class genericClassInClass {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Student student=new Student("张三");
		Generic<Student> generic=new Generic();
		Generic<Generic<Student>> generic2=new Generic<Generic<Student>>();
		generic2.setData(generic);
		generic.setData(student);	System.out.println(generic2.getData().getData().getDate());
	}
}
class Generic<T>{
	private T data;
	public Generic() {	
	}
	public Generic(T data) {
		this.data=data;
	}
	public void setData(T data) {
		this.data=data;
	}
	public T getData() {
		return data;	
	}
}
class Student {
	private String name;
	public Student(String name) {
		this.name=name;
	}
	public void setDate(String name) {
		this.name=name;
	}
	public String getDate() {
		return name;
	}
}

4.泛型类继承泛型类且实现接口

package GenericClass;
public class extendGeneric {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		@SuppressWarnings("unchecked")
		bellowGeneric<String,Integer> bellow=new bellowGeneric("张三", 15);
		System.out.println(bellow.getData());
		System.out.println(bellow.print());
	}
}
class superGeneric<T1>{
	private T1 data;
	public superGeneric(T1 data) {
		this.data=data;
	}
	public void setData(T1 data) {
		this.data=data;
	}
	public T1 getData() {
		return data;
	}
}
class bellowGeneric<T1,T2> extends superGeneric<T1> implements test<T2> {
	private T2 data2;
	public bellowGeneric(T1 data,T2 data2) {
		super(data);
		// TODO 自动生成的构造函数存根
		this.data2=data2;
	}
	public T2 getData2() {
		return data2;
	}
	@Override
	public T2 print() {
		// TODO 自动生成的方法存根
		return data2;
	}
} 
interface test<T2>{
	public abstract T2 print();
}

5.限制泛型的接收参数

使用extends关键字可以限制接收的类型，接收的是接口的实现类或者子类

6.泛型通配符

下边界 extends

上边界 super

7.泛型方法

比重载更 牛

三十.Java 集合

1.集合框架

要实现对象的比较方法必须实现comparator接口

compareTo 是字符或者数默认自带的比较方法

2.ArrayList

3.LinkedList–链表

此链表即继承了List又继承了queue

内部封装双向链表结构,

特点

插入，删除的效率比较高，但查询效率比较低

使用linkedList实现栈和队列的功能

/* 栈 */
package Java集合框架;
import java.util.Iterator;
import java.util.LinkedList;
public class linkListDemo1 {		
	public static void main(String[] args) {
			myStack<String> Stack=new myStack();
			Stack.push("chenhao");
			Stack.push("zhangsan");
			Stack.push("wangwu");
			Stack.push("zhaoliu");
			Stack.push("ligang");
			Stack.pop();
			Stack.pop();
			Iterator<String> it=Stack.iterator();
			while(it.hasNext()) {
				String name=it.next();
				System.out.println(name);		
			}			
	}
}
class myStack<T>{
	private LinkedList<T> list=null;
	public myStack() {
		list=new LinkedList<T>();
	}
	public void push(T var) {
		list.addFirst(var);
	}
	public void pop() {
		list.removeFirst();
	} 
	public Iterator<T> iterator(){
		return list.iterator();
	} 
}

/* 队列*/ 
/*
*只是在pop出的时候采用的是
*list.removeLast();
*/

4.HashMap

hashMap的内部实现 —数组单向列表结构

5.treeMap — 红黑树Map接口

package Java集合框架;
import java.util.TreeMap;
public class treeMapDemo1 {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		TreeMap<Student,String> tree=new TreeMap<>(); 	
		tree.put(new Student("zhangsan",12),"张三");
		tree.put(new Student("lisi", 22),"李四");
		tree.put(new Student("wangwu", 18),"王五");
		tree.put(new Student("zhaoliu", 25),"赵刘");	
		System.out.println(tree);
		
	}
}
class Student implements Comparable<Student>{
	private String name;
	private int age;
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	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;
	}
	@Override
	public int compareTo(Student o) {
		// TODO 自动生成的方法存根
		if(this.age-o.getAge()>0) {
			return 1;
		}else if(this.age-o.getAge()<0) {
			return -1;
		}
		else {
			return 0;
		}
	}
}

6.HashSet

操作的就是hashmap的键

7.TreeSet

8.collections

对集合框架进行服务

里面含有很多静态方法供list和map的实现类使用

collection 是一个接口 list set 继承它

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bxArJdCP-1610727644326)(C:\Users\Dell\AppData\Roaming\Typora\typora-user-images\1610248934519.png)]

三十一.GUI

本部分只介绍一下，想要更深的学习请自行百度

三十二.Java反射

1.反射概念

2.class对象的获取

三十三.线程

创建一个线程类—继承thread 或者 runnable 然后重写run 方法 然后 调用start方法

①thread类

②runnable方法

建议使用第二种方式进行创建线程,第二种可以实现数据的共享

package thread;
public class SellTick {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		SellTicks sk=new SellTicks();
		Thread td=new Thread(sk,"一号");
		td.start();
		Thread td2=new Thread(sk,"二号");
		td2.start();
	}
}
class SellTicks implements Runnable{
	private int num=5;
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		while(num>0)
		System.out.println("当前卖票的窗口为:"+Thread.currentThread().getName()+"剩余:"+(num--));
	}
}

• 线程的生命周期

  • 
  • 
  • 
  • 

• 多线程编程

  • 线程同步(synchronizede)

    • 防止多个线程同时访问一个资源

    • package thread;
      public class Bank {
      	public static void main(String [] args) {
      		Banks bank=new Banks();
      		BankThreads bs1=new BankThreads("张三", bank);
      		bs1.start();
      		BankThreads bs2=new BankThreads("张三", bank);
      		
      		bs2.start();
      	}
      }
      class BankThreads extends Thread{
      	private Banks bank=null;
      
      	public BankThreads(String name,Banks bank) {
      		super(name);
      		this.bank=bank;
      	}
      	public void run() {
      		
      		
      			System.out.println("取钱"+bank.getMoney(400));
      		
      	
      	}	
      }
      class Banks{
      	private int money=500;
      	public synchronized int getMoney(int num) {
      		if(num<0) {
      			return -1;
      		}
      		else if(money<0) {
      			return -2;
      		}
      		else if(num-money>0) {
      			return -3;
      		}
      		else {
      			try {
      				Thread.sleep(1000);
      			} catch (InterruptedException e) {
      				// TODO 自动生成的 catch 块
      				e.printStackTrace();
      			}
      			money-=num;
      			System.out.println("剩余的钱:"+(money-num));
      		}
      		return num;
      	}
      }
      

  • 同步和锁

    • 一个对象只有一个锁
    • 只有含有这个锁的线程才能运行次资源
    • 死锁
      • 两个线程同时竞争彼此的资源

  • 线程通讯

    • 

三十三.IO流

1.概念

2.File

3.递归算法

自己调用自己-------有出口

阶乘

4.流的概念

以内存为参照物

把外部的文件输入到内存中就是 输入流

• 流的分类
  • 

5.字节流(InputStream/OutputStream)

6.文件输入输出流

缓冲区复制文件 —提高文件的效率

下饭的项目

一.万年历

package wanninali;
import java.util.Scanner;
public class YearWnDemo {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int year,month,day=0,totalDays=0;
		boolean Wn;
		System.out.println("*************欢迎使用万年历*************");
		System.out.println("请输入年份");
		Scanner input=new Scanner(System.in);
		year=input.nextInt();
		System.out.println("请输入月份");
		month=input.nextInt();
		if(year%400==0||(year%100!=0&&year%4==0)) {
			Wn=true;		//true ---润年
		}
		else
			Wn=false;
/*		总体分析:1.计算输入的年份到1900年的天数
					1.1 计算输入年份之前的年的总天数
			    2.计算输入的月份之前的总天数；
			    3.算出星期几，xingqi=1+totaldays%7;*/
		for(int i=1900;i<year;i++) {
			if(i%400==0||(i%100!=0&&i%4==0)) {
				totalDays+=366;
			}
			else {
				totalDays+=365;
			}
		}
		for(int i=1;i<=month;i++) {
		switch(month) {
		case 1:
		case 3:
		case 5:
		case 7:
		case 11:
		case 12:
				day=31;
				break;
		case 2:
			if(Wn) day=29;
			else   day=28;
			break;
		case 4:
		case 6:
		case 8:
		case 10:
			day=30;
		default:
			System.out.println("您输入的月份不正确!");
		}
		if(i!=month) {
			totalDays+=day;
		}
		}
//		算出周几
		int xingqi;
		xingqi=1+totalDays%7;
		if(xingqi==7) {
			xingqi=0;
		}
		System.out.println("周日\t周一\t周二\t周三\t周四\t周五\t周六");
		for(int i=1;i<=xingqi;i++) {
			System.out.print("\t");
		}
		for(int i=1;i<=day;i++) {
			System.out.print(i+"\t");
			if((xingqi+i)%7==0) {
				System.out.println();
			}
		}
		System.out.println("你输入的月份:"+month+"所对应的天数为:"+day);
	}
}

二.雇员–练习String方法

package String;
public class Employee {
		int age;
		String name;
		public String toString(){
			return "大家好,我叫:"+name+",今年"+age+"岁了";
		}
		public int CountFriends(String src,String dir) {
			int count=0;
			int index=src.indexOf(dir);
			while(index!=-1) {
				count++;
				int position=index+dir.length();
			   index=src.indexOf(dir,position);
			}
			return count;
		}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Employee e=new Employee();
		e.age=18;
		e.name="张三";
		System.out.println(e.toString());
		System.out.println("朋友出现的次数:"+e.CountFriends("朋友啊朋友,", "朋友"));	
	}
}

三.多态–打印机

拿父类的引用变量作为参数,可以接受任何其子类的对象

越抽象越稳定，越好！

package duotai;

public class PrinterDemo1 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
			school school=new school();
			ColorPrinter cp=new ColorPrinter("戴尔");
			school.setPrinter(cp);
			school.setContet("hello!");
	}

}

class school{
	@SuppressWarnings("unused")
	private Printer p=null;
	public void setPrinter(Printer p) {
		this.p=p;
	}
	public void setContet(String content) {
		p.setContent(content);
	}
}

class Printer{
	private String Brand;
	public Printer(String brand) {
		this.Brand=brand;
	}
	
	public String getBrand() {
		return Brand;
	}
	public void setContent(String content) {
		
	}
}

class ColorPrinter extends Printer{
	public ColorPrinter(String brand) {
		super(brand);
	}
	public void setContent(String content) {
		System.out.println(getBrand()+content);
	}
}

四.多态—士兵

package soldier;

public class SoldierDemo1 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
			Soldier landSoldier=new landSoldier("张三");
			officer order=new officer("陈浩");
//		命令全部开火
			order.start();
			//命令某一个士兵攻击
			order.start(order.getCertainSoldier()[1]);		
	}
}
abstract class Soldier{
	private String name;
	public Soldier(String name) {
		this.name=name;
	}
	public void action() {
		prepare();
		attack();
		end();
	}
	public void prepare() {
		System.out.println("准备攻击");
	}
	public void end() {
		System.out.println("停止攻击");
	}
	public abstract void attack();
	public String getName() {
		return name;
	}
}
class landSoldier extends Soldier{
	public landSoldier(String name) {
		super(name);
		// TODO 自动生成的构造函数存根
	}

	@Override
	public void attack() {
		// TODO 自动生成的方法存根
		System.out.println(getName()+" 使用大炮攻击!");
	}
}
class oceanSoldier extends Soldier{
	public oceanSoldier(String name) {
		super(name);
		// TODO 自动生成的构造函数存根
	}
	@Override
	public void attack() {
		// TODO 自动生成的方法存根
		System.out.println(getName()+" 使用鱼雷攻击!");
	}
}
class officer extends Soldier{
	Soldier[] soldier =new Soldier[2];
	public officer(String name) {
		super(name);
		// TODO 自动生成的构造函数存根	
		soldier[0]=new landSoldier("张三");
		soldier[1]=new landSoldier("李四");
	}

	@Override
	public void attack() {
		// TODO 自动生成的方法存根
		System.out.println(getName()+" 使用手枪攻击!");
	}
	public void start() {
		for(int i=0;i<soldier.length;i++) {
			soldier[i].action();
		}
		attack();
	}
	public void start(Soldier s) {
		s.action();
	}
	public Soldier[] getCertainSoldier() {
		return soldier;
	}
}

五.内部类对数据的封装

package 内部类1;
import java.util.Arrays;
public class EntryDemo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Mycontainer container=new Mycontainer();
		container.Put("json","陈浩");
		container.Put("Mine","李明");
		container.Put("Rose","玫瑰");
		container.Put("Xind","雷达");
		container.Put("Army","大炮");
		container.Put("json","陈浩");
		Mycontainer.Entry [] entry= container.GetArray();
		for(int i=0;i<entry.length;i++) {
			Mycontainer.Entry entry1=entry[i];
			System.out.println(entry1.Getkey()+"--"+entry1.GetValue());	
		}
	}
}
 class Mycontainer{
	   Entry [] entrys=new Entry[5];
	   int count=0;
	   public void Put(String key,String value) {
		   Entry entry=new Entry();
		   entry.key=key;
		   entry.value=value;
		   entrys[count++]=entry;
		   if(count>=5) {
			   int NewCapacity=entrys.length*2;
			   entrys=Arrays.copyOf(entrys, NewCapacity);
			   
		   }
	   }
	   public Entry [] GetArray(){
		   
	return Arrays.copyOfRange(entrys, 0, count);
	   }
	 
public static class Entry{
			private String key;
			private String value;
		public void SetKey(String key) {
			this.key=key;
		}	
		public String Getkey() {
			return key;
		}
		public void SetValue(String value) {
			this.value=value;
		}	
		public String GetValue() {
			return value;
		}	
	 }
 }

六.随机验证码

package 验证码;
import java.util.Random;
public class RandomCode {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
			System.out.println("随机的验证码为:\n"+CodeDemo.RandomNumber());
	}
}
class CodeDemo{
	public static String RandomNumber() {
		char [] s= {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','S','Y','Z','0','1','2','3','4','5','6','7','8','9'};
		Random random=new Random();
		int count=0;
		StringBuilder st=new StringBuilder();
	   while(true) {
		   char b=s[random.nextInt(s.length)];
		   if(st.indexOf(b+"")==-1) {
			   st.append(b);
			   count++;
			   if(count==4) {
				   break;
			   }
		   }
		   
	   }
	   return st.toString();	
	}	
}

七.医生给工作者看病

package 异常;
import java.util.Random;
public class Hosipital {
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
   Worker work=new Worker();
   doctor doc=new doctor();
	try {
    work.Work();	 
	}	
	catch(sickException e) {
		 doc.cure(work);
		 if(work.getState().equals("治愈完毕")) {
			 System.out.println("恭喜你可以恢复咯!");
		 }else {
			 System.out.println("Sorry,我们已经尽力了！");
		 }
	}
	finally{
		System.out.println("欢迎下次光临本医院!");
	}
	}
}

class Worker{
	private String State;
	public String getState() {
		return State;
	}
	public void setState(String state) {
		this.State = state;
	}
	public void Work() throws sickException {
		Random random=new Random();
		int n=random.nextInt(3)+1;
		if(n==1) {
			throw new sickException("已经生病");
			
		}else {
			System.out.println("很健康！");
		}
	}
}
class sickException extends Exception{
	private String Message;
   public sickException(String Message) {
	   this.Message=Message;
   }
   public String getMessage() {
	   return Message;
   }
}
class doctor{
	public void cure(Worker work) {
		Random rn=new Random();
		int r=rn.nextInt(2)+1;
		if(r==1) {
			
			work.setState("治愈完毕");
		}
		else {
			work.setState("Sorry");
		}	
	}	
}

八.统计字符串出现的次数–hashMap

package Java集合框架;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class AccountStringDemo1 {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
			String [] str= {"zhangsan","lisi","wangwu","zhangsan","chenhao"};					Account.printlnMap(Account.accout(str));
			
	}
}
class Account{
		public static Map<String,Integer> accout(String [] data){
			Map<String,Integer> map=new TreeMap<String, Integer>();
			for(int i=0;i<data.length;i++) {
				String str=data[i];
				if(map.get(str)==null) {
					map.put(str, 1);
				}else {
					map.put(str, map.get(str)+1);
					
				}
				
			}
			return map;	
		}
		public static void printlnMap(Map<String,Integer> map) {
			Set<Map.Entry<String,Integer>> maps=map.entrySet();
			for(Map.Entry<String,Integer> all:maps) {
				System.out.println(all.getKey()+"--"+all.getValue());
			}	
		}
}

This is my Git ➡️ https://88888888.com

关于我

• 个人博客
• 技术笔记
• GitHub
• 码云
• 简书
• 优快云
• 知乎
• 微博
• 主要涉及技术：Java后端开发、聚合支付、公众号开发、开源爱好者、Linux

ic void cure(Worker work) {
Random rn=new Random();
int r=rn.nextInt(2)+1;
if(r==1) {

		work.setState("治愈完毕");
	}
	else {
		work.setState("Sorry");
	}	
}	

}

#### 八.统计字符串出现的次数--hashMap

package Java集合框架;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class AccountStringDemo1 {

public static void main(String[] args) {
	// TODO 自动生成的方法存根
		String [] str= {"zhangsan","lisi","wangwu","zhangsan","chenhao"};					Account.printlnMap(Account.accout(str));
		
}

}
class Account{
public static Map<String,Integer> accout(String [] data){
Map<String,Integer> map=new TreeMap<String, Integer>();
for(int i=0;i<data.length;i++) {
String str=data[i];
if(map.get(str)==null) {
map.put(str, 1);
}else {
map.put(str, map.get(str)+1);

			}
			
		}
		return map;	
	}
	public static void printlnMap(Map<String,Integer> map) {
		Set<Map.Entry<String,Integer>> maps=map.entrySet();
		for(Map.Entry<String,Integer> all:maps) {
			System.out.println(all.getKey()+"--"+all.getValue());
		}	
	}

}

   **This is my Git ➡️ [https://88888888.com](https://github.com/chenchen1314)**
# 关于我
- [个人博客](https://chenchen1314.github.io/)
- [技术笔记]()
- [GitHub](https://github.com/chenchen1314)
- [码云]()
- [简书](https://www.jianshu.com/u/6883ab64ef22)
- [优快云](https://blog.youkuaiyun.com/h949548472)
- [知乎](https://www.zhihu.com/people/chenchen1314)
- [微博](//weibo.com/chblog1314)
- **主要涉及技术：`Java后端开发`、`聚合支付`、`公众号开发`、`开源爱好者`、`Linux`**