java基础学习笔记2

（小白自学，供复习时用，如有不得当之处，烦请大神指教）

视频一直都给我的感觉很不好，一直喜欢看书，找工作急需，目前就先了解大概喽（20160109）

【扣丁学堂】

Test19介绍的是工厂模式，没什么，就是具体的东西抽象化

package practice05;

public class Test19 {
	public static void main(String[] args){
		/*
		 * 偶合：使用者直接使用了
		 */
	//	TCLPhone phone=new TCLPhone();
	//	phone.working();
		//下面方式降低偶合度
		Work work=Factory.getWork("phone");
		if(work!=null){
			work.working();
		}
	}
}
//工厂模式
class Factory{
	public static Work getWork(String product){
		if("phone".equals(product)){
			return new TCLPhone();
		}else if("tv".equals(product)){
			return new TCLTV();
		}else{
			return null;
		}
	}
}
interface Work{
	public void working();
}
class TCLPhone implements Work{
	public void working(){
		System.out.println("starting");
	}
}
class TCLTV implements Work{
	public void working(){
		System.out.println("play news");
	}
}

Test20好像和Test19讲的都是设计模式，Test20讲的是代理的设计模式，就是代理帮你做一些事情（这些事情你和代理做效果一样），然后你就可以少做一些（必要的）

package practice05;
/**
 * 代理设计模式
 * @author Administrator
 *
 */
public class Test20 {
	public static void main(String[] args){
		SuperMan man=new SuperMan();
		Proxy prox=new Proxy(man);
		prox.shopping();
	}

}
//主题
interface Subject{
	public void shopping();
}
class SuperMan implements Subject{
//	private String name;
	public void shopping(){
		
		System.out.println("for wife, I bought commoditys");
		//
	}
}
//代理
class Proxy implements Subject{
	private Subject target;
	public Proxy(Subject target){
		this.target=target;
	}
	//实现接口的方法
	public void shopping(){
		//代购之前要做的事情
		System.out.println("priacte");
		target.shopping();
		
		//代购后要做的事情
	}
}

Test21讲的是适配器模式，以电源器为例，你的手机不能接这个电源，就要用一个转接口来当中介实现，在java中就是用类来继承（implements）

package practice05;
//适配器模式
public class Test21 {
	public static void main(String[] args){
		PowerA a=new PowerAImpl();
		input(a);
		PowerB b=new PowerBImpl();
		//input(b);//不能直接用，input只能接收a
		PowerAdapter adapter=new PowerAdapter(b);
		input(adapter);
	}
	public static void input(PowerA a){
		a.connect();
	}
}
//适配器
class PowerAdapter implements PowerA{
	private PowerB b;
	public PowerAdapter(PowerB b){
		this.b=b;
	}
	public void connect(){
		b.insert();
	}
}
interface PowerB{
	public void insert();
}
interface PowerA{
	public void connect();
}
class PowerBImpl implements PowerB{
	public void insert(){
		System.out.println("电源B开始工作");
	}
}
class PowerAImpl implements PowerA{
	public void connect(){
		System.out.println("电源A接口开始工作");
	}
}

Test22讲内部类，讲了好几种，都写到下面main里了，不过现在回顾记得是最好定义静态内部类

package practice05;
/*
 * 内部类
 * 外部类使用方法定义内部类（new内部类）
 * 通过外部类.内部类
 * 定义内部类时优先考虑今天内部类
 * @author Administrator
 *
 */
public class Test22 {
	public static void main(String[] args){
		Outer outer=new Outer();
		outer.print();
		
		//直接在外部是用内部类，不推荐
		Outer.InnerClass inner=outer.new InnerClass("在外部使用内部类");
		inner.print();
		//静态类，在外部直接使用静态内部类（创建静态内部类不需要依赖外部类的对象）
		//静态内部类在我们之后的android中会经常使用
		Outer.StaticInnerClass sic=new Outer.StaticInnerClass();
		sic.print();
		
		outer.print3();
		
		outer.print4(new Child(){
			public void desc(){
				System.out.print("参数内部类");
			}
		});
	}
}
class Outer{
	public void print(){
		InnerClass inner=new InnerClass("成员内部类");
		inner.print();
	}
	public void print2(){
		//在方法中定义内部类
		//实例化应该在方法里面
		int x=10;//内部类中不能改变x，只能使用，应该定义为final
		class InnerClass2{
			public void print(){
				System.out.println("在方法中定义内部类");
			}	
		}
		InnerClass2 inner=new InnerClass2();
		inner.print();
	}
	//内部类才能用static
	static class StaticInnerClass{
		public void print(){
			System.out.println("static inner class");
		}
	}
	class InnerClass{
		private String name;
		public InnerClass(String name){
			this.name=name;
		}
		public void print(){
			System.out.println(name);
		}
	}
	public void print3(){
		/*
		 * 匿名内部类方法
		 * 
		 */
		Child c=new Child(){
			public void desc(){
				System.out.println("匿名内部类");
			}
		};
		c.desc();
		/*
		class InnerClass3 implements Child{
			
		}*/
	}
	public void print4(Child c){
		c.desc();
	}
}
interface Child{
	public void desc();
}

Test23 链表（很经典），由外部方法进入内部方法并递归

package practice05;
/**
 * 很经典的一个例子
 * 链表数据结构
 * 用于频繁进行添加，插入，删除操作
 * @author Administrator
 *
 */
public class Test23 {
	public static void main(String[] args){
		NodeManager mm=new NodeManager();
		mm.addNode("1");
		mm.addNode("2");
		mm.addNode("3");
		mm.addNode("4");
		mm.addNode("5");
		mm.printNode();
		mm.delNode("4");
		mm.printNode();
	}
}

class NodeManager{
	private Node root;//根节点
	
	//提供给外部用的三个方法
	public void addNode(String name){
		if(root==null){
			root=new Node(name);
		}else{
			root.add(name);
		}
	}
	public void delNode(String name){
		if(root.getName().equals(name)){
			root=root.next;
		}else{
			root.del(name);
		}
	}
	public void printNode(){
		if(root!=null){
			System.out.print(root.getName()+"->");
			root.print();
			System.out.println();
		}
		
	}
	//每个节点对象
	class Node{
		private String name;
		private Node next;//表示当前节点下一个节点
		public Node(String name){
			this.name=name;
		}
		public String getName(){
			return name;
		}
		//添加节点
		public void add(String name){
			if(this.next==null){
				this.next=new Node(name);
			}else{
				this.next.add(name);//递归
			}
		}
		//删除节点
		public void del(String name){
			if(this.next!=null){
				if(this.next.name.equals(name)){
					this.next=this.next.next;
				}else{
					this.next.del(name);
				}
			}
		}
		//打印节点
		public void print(){
			if(this.next!=null){
				System.out.print(this.next.getName()+"->");
				this.next.print();
			}
		}
	}
}

Test24 讲java是完全面向对象的，不过我最感兴趣的是赋值-128~127的数时，返回true，而其他的却返回false

package practice05;

public class Test24 {
	public static void main(String[] args){
		int num=10;
		Integer num2=10;//自动装箱
		int num3=1+num2;//拆箱
		num2.intValue();
		
		//把一个之间内的整数缓存在整数常量池中，这样可以避免不断创建细粒度的对象，造成对内存的消耗
		//-128~127,,,下面的语句进行验证
		Integer a=200;
		Integer b=200;
		System.out.println(a==b);
	}

}

Test25 异常处理，有点迷糊，对于throw和throws

/**
 * try{
 * //
 * }catch{
 *  //
 * }
 */
package practice05;
import java.util.*;
public class Test25 {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		System.out.println("请输入数字：");
/*		try{
		int num3=input.nextInt();
		}catch(InputMismatchException e){
			System.out.println("输入的类型不匹配");
		}
		//try语句有可能出现异常
		try{
		int num1=10;
		int num2=0;
		System.out.println(num1/num2);
		}catch(ArithmeticException e){
			System.out.println("算数异常");
		}
*/		
			//try语句有可能出现异常
			try{
		    	int num3=input.nextInt();
		    	int num1=10;
		    	int num2=0;
		    	System.out.println(num1/num2);
			}
			//说下面的异常有等级，因此有先后顺序
			catch(ArithmeticException|InputMismatchException e){
				System.out.println("异常");
				System.out.println(e.getMessage());
			}
//			catch( e){
//				System.out.println("输入的类型不匹配");
//			}
			finally{
				//最后，可以做一些回收，清理的工作
				System.out.println("finally语句不管会不会出现异常，都会执行");
			}
		System.out.println("over");
		try {
			exTest2(10,2);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	private static int exTest2(int num1,int num2)throws Exception{
		//return num1/num2;
		if(num2==0)throw new ArithmeticException("ddddd");
		return num1/num2;
	}
}