前言：
 

封装、继承、多态之后抽象以及接口的学习需要特别重视！！！

补：

String 方法是在堆之中

 

面向对象思想：

抽象类，没有业务意义，比如宠物吃东西， 我们借用abstract 设计抽象类，此时编译器会进行提示

Note：

构造函数不能抽象，抽象类中可以有抽象方法供子类调用

接口：

JAVA借用接口实现多继承，这一点与C++非常不一样。侧重点在行为

学习样例：

开发打印机---面向接口编程

需求：
墨盒；彩色，黑白

纸张：A4，B5

黑盒和纸张都不是打印机厂商提供的，打印机厂商要兼容市场上的墨盒、纸张

墨盒接口：得到颜色，  

实现接口：1.彩色  2.黑白

纸张接口 ：得到纸张

纸张类型：1.A4  2.B5

行为是打印：
输出：使用黑白墨盒在A4纸张上打印。

部分代码如下

接口

package com.ydl.ch04;

public interface Paper {
	
	public String getSize() ;
}

 实现接口

package com.ydl.ch04;

public class A4Paper implements Paper {
	String paper="A4纸张";
	@Override
	public String getSize() {
		this.paper="A4纸张";
		//System.out.println("使用"+paper);
		return paper;
	}

}

打印机类 

package com.ydl.ch04;

public class NewPrinter {
	public Paper paper;
	public Printer pri;
	public Paper getPaper() {
		return paper;
	}
	public void setPaper(Paper paper) {
		this.paper = paper;
	}
	public Printer getPri() {
		return pri;
	}
	public void setPri(Printer pri) {
		this.pri = pri;
	}
	public void display(){
		System.out.println("使用"+paper.getSize()+"进行"+pri.getInk()+"打印");
	}
	
}

测试类：

package com.ydl.ch04;

public class Test {
	public static void main(String[] args) {
		/*Paper pa1=new A4Paper();
		Printer pr1=new ColorPrint();
		System.out.println(pa1.getSize()+pr1.getInk());
		Paper pa2=new B5Paper();
		Printer pr2=new InkPrint();
		System.out.println(pa2.getSize()+pr2.getInk());*/
		A4Paper a4=new A4Paper();
		ColorPrint c4=new ColorPrint();
		NewPrinter n4=new NewPrinter();
		n4.setPaper(a4);
		n4.setPri(c4);
		n4.display();
		B5Paper b5=new B5Paper();
		InkPrint c5=new InkPrint();
		NewPrinter n5=new NewPrinter();
		
		n5.setPaper(b5);
		n5.setPri(c5);
		n5.display();
		
		n5.setPaper(a4);
		n5.setPri(c5);
		n5.display();
		
		n5.setPaper(b5);
		n5.setPri(c4);
		n5.display();
	}
}

Notes：

与C++不同，JAVA不用直接的多继承，而采用接口，实现多继承

静态：

静态方法的调用：尽量使用类名来调用，免得与普通方法弄混，当然JAVA编译器会帮我们进行优化

静态代码块：
不需要调用就会加载

 

下面附上小马哥笔记

 

 static成员在JVM中的存储

 

如何理解接口是一种能力

1. 可以被多继承
2. 设计和实现完全分离
3. 更自然的使用多态
4. 更容易搭建程序框架
5. 更容易更换实现：比如插座，提供充电的功能，比如市场上所有插座的都是2-3个插口

线程学习：

实际开发用得少，面试却比较多

线程的实现有两种方式：

• extends Thread 继承来实现
• implememnts Runable 借助接口来实现

线程优先级：1--10

线程的调度：
1.static void sleep(毫秒);

2void join();强制执行

3.static void yield()礼让

4.void interupt()

通过几个案例进行学习：

同步锁以及Runable接口实现：黄牛抢票、1000接力赛
线程强制、礼让：医院叫号：

线程休眠：多人爬山：

   具体需求可以操作网上其他网站；

主要目的：

同步锁、Runable接口实现方式的资源共享的学习：

黄牛抢票、1000接力赛其实是同个问题

package com.projo;

public class Site implements Runnable{
	int total=10;//剩余票数
	int currNumber=0;//当前票数
	boolean result=true;
	
	@Override
	public void run() {
		while(total>0){
			//System.out.println(Thread.currentThread().getName());
			synchronized (this) {
				if (total<=0) {
					break;
				}
				try {
				Thread.sleep(500);
				total--;
				currNumber++;
				System.out.println(Thread.currentThread().getName()+
						"抢到第"+currNumber+"还剩"+total+"张票");
				} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				}
			}
			
		}
	}

}

测试主函数入口：

package com.projo;

public class TestSite {
	public static void main(String[] args) {
		Site s=new Site();
		
		Thread p1=new Thread(s,"黄牛");
		p1.setPriority(8);
		Thread p2=new Thread(s,"学生");
		Thread p3=new Thread(s,"老师");
		
		p1.start();
		p2.start();
		p3.start();
		
	}
}

线程强制与礼让问题：

 医院叫号：

package com.projo;

public class TestCallThread {

	public static void main(String[] args) {
		CallThread call=new CallThread();
		Thread c1=new Thread(call,"特殊号：");
		c1.start();
		for (int i = 1; i <= 50; i++) {
			if (i==10) {
				try {
					c1.join();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			try {
				c1.sleep(100);
				c1.currentThread().setName("普通号：");
				System.out.println(c1.currentThread().getName()+"第"+i+"个病人再看病！");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}

 

最后贴上多线程模拟接力赛跑步：

package com.runprojo;

public class Relay implements Runnable {
	
	private int num=10;//每人跑10m
	private int total=1000;//总共1000
	
	@Override
	public void run() {
		while(total>=0){
			synchronized (this) {
				System.out.println(Thread.currentThread().getName()+"拿到接力棒");
				if (total==0) {
					System.out.println("比赛结束");
					break;
				}
				total-=100;
				try {
					for (int i = 1; i <=num; i++) {
						System.out.println(Thread.currentThread().getName()+"跑了"+i*10+"m");
						Thread.sleep(500);
					}
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

}

 测试入口：

package com.runprojo;

public class TestRelay {

	public static void main(String[] args) {
		Relay run=new Relay();
		Thread runner1=new Thread(run,"1号选手");
		Thread runner2=new Thread(run,"2号选手");
		Thread runner3=new Thread(run,"3号选手");
		Thread runner4=new Thread(run,"4号选手");
		Thread runner5=new Thread(run,"5号选手");
		Thread runner6=new Thread(run,"6号选手");
		Thread runner7=new Thread(run,"7号选手");
		Thread runner8=new Thread(run,"8号选手");
		Thread runner9=new Thread(run,"9号选手");
		Thread runner10=new Thread(run,"10号选手");
		Thread runner11=new Thread(run,"11号选手");
		runner1.start();
		runner2.start();
		runner3.start();
		runner4.start();
		runner5.start();
		runner6.start();
		runner7.start();
		runner8.start();
		runner9.start();
		runner10.start();
		runner11.start();
		
		
		
	}

}