Java总结



一、java基础

1、类与对象

     类：是指生活中一类事物的集合

     类的分类：a、普通类  public class 类名(){}

                       普通类：可以存在变量和常量

                                      可以创建对象

                                      可以有普通方法和构造方法，一定不能有抽象方法

                       b、抽象类 public abstruct class 类名(){}

                        抽象类：可以存在变量和常量

                                      不可以创建对象

                                      三种方法都可以有

                       c、接口类：public interface 类名(){}

                       接口类：只能存在常量

                                      不可以创建对象

                                      只能存在抽象方法

仅仅限于一个类中的分类：内部类、方法内部类、匿名内部类(隐藏子类)

    对象：是指生活中所有的实体

2、属性与方法

      属性的定义格式：public 类名 属性名

      方法(函数)的分类

      普通方法：public 返回值 方法名(参数列表){方法体}

      构造方法：public 类名(参数列表){方法体}

      抽象方法：public abstract 返回类型 方法名(参数列表){方法体}

      a、方法重写：子类继承父类，重写父类方法，方法名、参数列表、返回类型必须相同，覆盖父类的方法

      b：方法重载：同一个类中，多个方法的方法名相同，参数列表和返回类型不同，则互为方法重载

3、java编程：

     面向对象编程的三大特征：封装、继承和多态

     面向对象：关注事情的结果

     面向过程：关注事情的执行流程

     oop面向对象编程

package Test;

public class Teacher {
	public String name1="张三";
	public String name2="李四";
	public static void main(String[] args) {
		Teacher th = new Teacher();
		th.teach();
	}
	public void teach(){
		System.out.println(name1+"正在给"+name2+"同学上课");
	}
}

打印的是：张三正在给李四同学上课

   引用传递：

package Test;

public class Test {
	public int a=1;
	public int b=2;
	public static void main(String[] args) {
		Test t = new Test();
		t.test();
	}
	public void test(){
		int c = a;
		a = b;
		b = c;
		System.out.println(a+"\r\n"+b);
	}
}

打印1

       2

继承的关键字：extends、implements(接口继承)

多态体现在继承上：多个同一个类型调用同一个方法，执行流程不一样

package Test;

public class People {
	public static void main(String[] args) {
		MiddleStudents ms = new MiddleStudents();
		Students s = new Students();
		ms.test();
		s.test();
	}
	public void test(){
		System.out.println("吃饭");
	}
}
package Test;

public class MiddleStudents extends People{
	public void test(){
		System.out.println("睡觉");
	}
}

package Test;

public class Students extends People{
	public void test(){
		System.out.println("做饭");
	}
}

打印输出的是：睡觉做饭

二、java线程同步

1、程序、进程、线程

     程序：一组指令的集合

     进程：正在运行的程序

     线程：是程序的特殊段，可以在程序里独立执行

2、区别与联系

     进程与程序：程序是静态的，进程是动态的，一个程序对应多个进程，一个进程对应一个程序

     进程与线程：进程有自己的独立的空间，线程只能共享进程中的空间，进程中至少有一个线程

3、java多线程

     java多线程可以提高CPU利用率

     java多线程可以同时执行多个任务，提高效率

    java支持多线程

4、线程的几种状态：线程创建——就绪（start）——运行（run方法执行）——睡眠（sleep）——等待/通知（wait/notify）——阻塞（synchronized）——死亡（run方法执行完毕）

package Test;

public class Test {
	public static void main(String[] args){
		Students s1 = new Students("iPhone");
		Students s2 = new Students("Meizu");
		new Thread(s1).start();
		new Thread(s2).start();
	}
}
package Test;

public class Students implements Runnable{
	private String name;
	private int count = 5;
	public Students(String name){
		this.name = name;
	}
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println(name+count--);
		}
	}
}

java多线程，如上，两个线程抢占CPU资源，先抢占的先执行，打印输出的是（每次打印输出的顺序都会不同）：

iPhone5
iPhone4
iPhone3
iPhone2
iPhone1
Meizu5
Meizu4
Meizu3
Meizu2
Meizu1

4、线程同步
1）线程通信分类；

“监视线程”通讯模型：一个线程控制多个线程运行程序

生产/消费模型:notify/wait来操作，例如生活中的需求分析，当供不应求时，就会通知生产商生产--notify，当供过于求时，则会暂时停止--wait

2）多个线程同时运行时，可能操作的是同一个对象，则需要通过synchronize关键字来锁定，只允许一个线程通过

synchronize只能有一个线程执行，任何一个对象有一个标识位，有0,1两种状态，synchronize在执行代码块是会检验对象的标识位，如果是1，则执行程序，同时也将

该对象的标识位设为0，处于阻塞状态，一直等到标识位为1时，再执行下面程序；

package Test;

public class Dumpling {
	public String name;
	public Dumpling(String name){
		this.name = name;
	}
}

package Test;

import java.util.ArrayList;

public class Mother implements Runnable{
	private ArrayList<Dumpling> list = new ArrayList<Dumpling>();
	public Mother(ArrayList<Dumpling> list) {
		this.list = list;
	}
	public void run() {
//		记录生产量
		int count = 0;
		while(true){
			synchronized (list) {
				if(list.size()>0){
					try {
						list.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				Dumpling dumpling = new Dumpling("做的饺子个数是："+count);
				count++;
				list.add(dumpling);
				list.notify();
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

package Test;

import java.util.ArrayList;

public class Son implements Runnable{
	private ArrayList<Dumpling> list = new ArrayList<Dumpling>();
	public Son(ArrayList<Dumpling> list) {
		this.list = list;
	}
	public void run() {
		while(true){
			synchronized (list) {
				if(list.size()==0){
					try {
						list.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				Dumpling dumpling = list.remove(0);
				System.out.println("吃的个数是"+dumpling.name);
				list.notify();
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

package Test;

import java.util.ArrayList;

public class Test {
	public static void main(String[] args){
		ArrayList<Dumpling> list = new ArrayList<Dumpling>();
		new Thread(new Mother(list)).start();
		new Thread(new Son(list)).start();
	}
}

如上述，用生活中的饺子做测试，生产者、消费者交替执行，打印输出的是：

吃的个数是做的饺子个数是：0
吃的个数是做的饺子个数是：1
吃的个数是做的饺子个数是：2
吃的个数是做的饺子个数是：3
吃的个数是做的饺子个数是：4
吃的个数是做的饺子个数是：5、、、、、、、、、

package UseSynchronize;

public class Acount {
	private int count;
	public Acount(int count){
		this.count = count;
	}
	public int getCash(int cash){
		synchronized (this) {
			if(count<cash){
				return 0;
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			count = count-cash;
		}
		return count;
	}
}




package UseSynchronize;

public class OperationThread implements Runnable{
	private Acount acount;
	private int cash;
	private String operation;
	public OperationThread(Acount acount,int cash,String operation){
		this.acount = acount;
		this.cash = cash;
		this.operation = operation;
	}
	public void run() {
		int count = acount.getCash(cash);
		if(count==0){
			System.out.println("本人在"+operation+"取现失败,余额为："+count);
		}else{
			System.out.println("本人在"+operation+"取现成功,余额为："+count);
		}
	}
}




package UseSynchronize;

public class TestInfunction {
	public static void main(String[] args) {
		Acount count = new Acount(5000);
		new Thread(new OperationThread(count,3000,"ATM")).start();
		new Thread(new OperationThread(count,3000,"柜台")).start();
	}
}

打印输出的是：本人在ATM取现成功,余额为：2000
本人在柜台取现失败,余额为：0，如果没synchronized关键字，则打印输出余额为负数，这不符合实际；

5、ArrayList、LinkedList的作用：

ArrayList：方便查询元素

LinkedList：方便添加和删除元素

HashMap：有key和value两个值，是一组有序的集合，可以重复

HashSet：无序的（第一次排序，下次就不会变了），不可以重复

HashTable：和HashMap一样都有键值存储，是线程同步

三、java关键字

1、 关键字定义：是电脑语言里事先定义的，被赋予了指定含义的单词，有特别意义的标识符，有时又叫保留字

1）跟类相关：public、protected、default、private、class、implements、extends、final、abstract、import、package

2）跟方法相关：void、return、static

3）循环判断：for、switch、case、do、while、break、continue、if、else

4）异常、try、catch、finally、throw、throws

5）其他：this、super

2、关键字命名

switch（表达式）{in/short/String（JDK1.7以前不能用）枚举类型case（表达式）：、、、、、、break；}

1）访问修饰符

public：公有的，整个java工程都可以访问

protected：同一个包下的类可以访问，不同包不能访问，但可以通过继承，访问到受保护的属性或者方法

default：同一个包下的类可以随意访问，跨包不行

private：仅限于当前类可以访问，其他类拥有该类的对象，也无法访问其属性和方法

2)this/super

this：当前类的对象

super：父类的对象

普通方法和属性的调用：this.方法名，this.属性名，super.方法名，super.属性名

this()；——调构造方法示例：

<pre class="java" name="code">package Test;

public class TestOne {
	private String name;
	public TestOne(String name){
		this.name = name;
	}
	public TestOne(){
		this("高普");
	}
}

注意：1、this()和super()必须出现在第一行

           2、方法重写，如果要对父类方法进行补充，则需要调用super.父类方法名()方法名定义

3、final（最终的）

可以用来修饰：类、方法、属性、参数、局部变量

修饰类：当前类不能被继承

修饰方法：当前方法不能被重写

修饰属性：当前属性只能被赋值一次，而且必须是常量

4、static（静态的）

可以用来修饰：属性、方法、静态块

注意：静态方法中一定不能直接使用非静态的属性和方法

package Test;

public class Son {
	protected static String name;
//	当前类运行时执行
	static{
		System.out.println("吃饭");
	}
//	创建对象时执行
	{
		System.out.println("睡觉");
	}
}




package Test;

public class Father {
	public static void main(String[] args) {
		Son son = new Son();
		Son son1 = new Son();
		son.name = "张三";
		son1.name = "李四";
		Son.name = "王五";
		System.out.println(son.name);
		System.out.println(son1.name);
		System.out.println(Son.name);
	}
}

打印输出的是：吃饭
睡觉
睡觉
王五
王五
王五

因为静态属性只能由类名定义，所以是三个王五，前面的代码块是创建对象是执行，创建了两次，所以出现两次"睡觉"

四、java异常分类

java中所有异常的父类是Exception，分为受检异常和非受检异常，所有的非受检异常都是RuntimeException的子类，也是Exception的子类，RuntimeException作为非受检异常

，它的子类有：NullPointException、ArithmeticException、EvenException、、、、、例如以下：

1、非受检异常（运行异常）

package ExceptionClass;

public class TestException {
	public static void main(String []args){
		TestException te = new TestException();
		te.test(2, 0);
	}
	private int test(int a,int b){
		int value = a/b;
		return value;
	}
}

出现的异常则是：ArithmeticException出现的异常

package ExceptionClass;

import javax.swing.JFrame;

public class TestJFrame{
	private static JFrame jf;
	public static void main(String[] args) {
		jf.setVisible(true);
	}
}

这个则是：NullpointException出现的异常，由于没有给相应的地址

2、受检异常（非运行异常）

但凡继承了Exception，没有继承RuntimeException，都是受检异常

java异常处理机制

1）捕获异常

在Java中，非运行异常一般通过try——catch语句进行捕捉，一半语句形式为：
try{
//可能发生异常的代码程序
}catch{
//执行异常操作
}
catch{
//执行异常操作
}.......
finally{
处理完try与catch操作完后收尾操作，异常统一出口
}

注意：try语句不可以省略，finally语句可以省略，可以有多重catch

Java中简单的测试：

package ExceptionClass;

public class TestExcept {
	public static void main(String[] args) {
		TestExcept te = new TestExcept();
		te.excpt(2, 0);
	}
	private int excpt(int a,int b){
		int value = 0;
		try{
			value = a/b;
		}catch(ArithmeticException e){
			e.printStackTrace();
		}finally{
			System.out.println("程序正常结束");
		}
		return value;
	}
}

控制台打印的是：程序正常结束
java.lang.ArithmeticException: / by zero
 at ExceptionClass.TestExcept.excpt(TestExcept.java:11)
 at ExceptionClass.TestExcept.main(TestExcept.java:6)，

由此可见，尽管程序出现异常，finally最终还得执行

2 ) 抛出异常

package ExceptionClass;

public class TestThrows {
	public static void main(String[] args) throws ArithmeticException{
		int i = 2;
		int j = 0;
		try{
			System.out.println(i/j+"的只是："+i/j);
		}catch(ArithmeticException e){
			throw new ArithmeticException();
		}finally{
			System.out.println("执行了finally语句");
		}
	}
}

打印输出的是：Exception in thread "main"

java.lang.ArithmeticException
 at ExceptionClass.TestThrows.main(TestThrows.java:10)
执行了finally语句，上述则是介绍了异常抛出