类和类之间的关系
- 泛化关系。类和类之间的继承及接口和接口之间的继承 is a
- 实现关系。接口与实现类之间的关系 is like a
- 关联 类与类之间的连接,一个类可以知道另一个类的属性和方法 has a
class A{
String name;
B b;
A(B b){
this.b=b;
}
}
class B{
String name;
A a;
}
4.聚和 是关联关系的一种是较强的关联关系,是整体与部分之间的关系 整体不依赖部分,部分也不会依赖整体
5.合成 比聚和关系强,区别在整体和部分是紧密相连的,整体的生命周期决定部分的。
6.依赖 在一个类中创建另一个类的对象(注:通常是局部变量,形参)
UML
- 继承 实线空心箭头指向父类
- 实现 虚线的空心箭头指向父类
- 关联 实线箭头指向被引用的一方
- 聚和 首先满足关联关系 空心菱形和实线 空心菱形在整体一端
- 合成 实心菱形加实线 实心菱形在整体一端
-
依赖 虚线加箭头
线程的同步(加锁)
- Thread.sleep(毫秒)
- sleep方法是一个静态方法
- 该方法的作用:阻塞当前线程腾出CPU、让给其他线程
异步编程模型
t1线程执行t1的 t2线程执行t2的,两个线程之间不相互等待
同步编程模型
t1线程执行t1的 必须等某个线程执行结束之后才会执行另一个线程
什么时候要同步?为什么要引入线程同步?
1.为了数据的安全。
2.多线程共享一个数据
3.共享的数据涉及到修改操作
synchronized(共享对象){}把需要同步的代码放到同步语句块中
原理:
t1线程和t2线程
t1线程执行到此处遇到synchronize关键字就会去找this的对象锁
如果找到this对象锁则进入同步语句块中执行程序,当同步语句块中的代码执行结束之后
t1线程归还this的对象锁
在t1线程执行同步语句块的过程中,如果t2线程也过来执行以下代码,也遇到synchronize
关键字,所以也去找this的对象锁,但是该对象锁被t1线程持有,只能在这等待this对象的归还
synchronize关键字加到成员方法上,线程拿走的也是this的对象锁
synchronized添加到静态方法上,线程执行此方法的时候就会找类锁。
死锁:
羊群效应,哲学家吃饭
setDaemon(true); 守护线程
关于定时器的应用:
1.创建定时器
Timer t=new Timer();
2.指定定时任务
t.schedule(TimerTask task,new SimpleDateFormate("yyyy-MM-dd:ss SSS").parse("2017-03-28:00 000"),10*1000)
反射机制
java.lang.Class;
java.lang.reflect.Constructor;
java.lang.reflect.Filed;
类中的属性
public class User{
private String id;
public int age;
protected String addr;
}
public class Reflect{
public static void main(String []args){
//获取整个类
Class c=Class.forName("User");
Field[]fs=c.getField();
System.out.println(fs.length);
System.out.println(fs[0].getName());
Field[]fs=c.getDeclaredFields();
for(Field field:fs){
//获取修饰符
int i=Field.getModifiers();
System.out.println(i);
String strModifer=Modifier.toString(i);
System.out.println(strModifer);
//获取属性类型
Class type=field.getType();
System.out.println(type.getSimpleName());
//获取属性内容
System.out.println(field.getName());
}
}
}
作用:
1.反编译 .class --> .java
2.通过反射机制访问java对象的属性,方法,构造方法
关于java语言中的可变长参数
Properties p=new Properties();
FileReader fr=nre FileReader("clssInfo");
p.load(fr);
fr.close();
String className=p.getProoerty("className");
Object o=c.newInstance();
Class c=Class.forName(className);
//创建对象,如果属性是私有的
Field f=c.getDeclaredField("id");
f.setAccessable(true);
f.set(o,"110");
String id=f.get(o)
//获取形参
Method []m=c.getDeclaredMethods();
Class[]paremeter=m.getParameterTypes()
//通过反射机制获取
public class Test
{
public static void main(String []args){
Num num=new Num(1);
Thread t1=new Thread(new printOdd(num));
Thread t2=new Thread(new printEven(num));
t1.start();
t2.start();
}
}
class Num{
int count;
Num(int count){
this.count=count;
}
public synchronized void printOdd(){
System.out.println(Thread.currentThread().getName()+"---->"+count++);
this.notifyAll();
try{this.wait();}catch(Exception e){
e.printStackTrace();
}
}
public synchronized void printEven(){
System.out.println(Thread.currentThread().getName()+"---->"+count++);
this.notifyAll();
try{this.wait();}catch(Exception e){
e.printStackTrace();
}
}
}
class printOdd implements Runnable{
Num num;
printOdd(Num num){
this.num=num;
}
public void run(){
while(true){
num.printOdd();
}
}
}
class printEven implements Runnable
{
Num num;
printEven(Num num){
this.num=num;
}
public void run(){
while(true){
num.printEven();
}
}
}