工作内容:
1.成员内部类 与成员方法,属性的访问权限一致
2.静态内部类 修饰符 stactic 类名{...}
3.匿名内部类 new 类名()/接口名(重写接口方法)
4.局部内部类 代码块中
5.线程Thread wait,notify
学习分享:
谁去调用notify(),就解开谁,如果有多线程正在等待这个Object,则随机执行一个线程
1)调用某个对象的wait()方法能让当前线程阻塞,并且当前线程必须拥有此对象的monitor(即锁)
2)调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程,如果有多个线程都在等待这个对象的monitor,则只能唤醒其中一个线程;
3)调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程;
4) wait()和notifyAll()都应该放于synchorized同步代码块中
注意:notify()和notifyAll()方法只是唤醒等待该对象的monitor的线程,并不决定哪个线程能够获取到monitor。
内部类实例:
public class Demo {
public static void main(String[] args) {
OuterClass out = new OuterClass();
//成员内部类
out.new People1().speak("传递String");
//out.new People1().show();
//静态内部类
//OuterClass.PeopleStatic.show();
}
}
public class OuterClass {
public static void main(String[] args) {
//测试同一个类中
OuterClass outer = new OuterClass();
//私有内部类的使用
outer.getPeople().show();
new OuterClass(). new People().show();
//成员内部类的使用
OuterClass.People1 people1 = outer.new People1();
people1.speak("传递String");
//静态内部类
int z = OuterClass.PeopleStatic.speak(3,5);
System.out.println(z);
}
//私有内部类
private class People{
public void show(){
System.out.println("成员内部类");
}
}
public People getPeople(){
return new People();
}
public void getInstance(){
new People().show();
}
//成员内部类
String string = "外部类string";
class People1{
String string = "内部类string";
public void speak(String string){
System.out.println(string);//传递的string
System.out.println(this.string);//内部类的string
System.out.println(OuterClass.this.string);//外部类string
}
private void show(){
System.out.println("成员内部类show");
}
}
//静态内部类
private static class PeopleStatic{
/**
* 静态内部类的方法需在外面打点调用,则方法必须是静态方法
* 静态内部类的方法需在外面生成对象,可以对象打点调用非private ,static修饰的方法
* @param x
* @param y
* @return
*/
private static int speak(int x,int y){
return x*y;
}
public static void show(){
System.out.println("静态内部类 静态方法show");
}
}
}
实例2://测试synchronized(obj){}中wait和notify的使用
public class StaticObjectTestLock {
public static Object a = new Object();
public static Object b = new Object();
public static Object c = new Object();
public static Object d = new Object();
static int x=6;
public static void main(String[] args) throws InterruptedException {
new LockObj(1).start();
//调用sleep保证其顺序执行
Thread.sleep(500);
new LockObj(3).start();
Thread.sleep(500);
new LockObj(2).start();
Thread.sleep(500);
new LockObj(4).start();
}
}
class LockObj extends Thread{
public int x;
public LockObj(int x) {
this.x = x ;
}
@Override
public void run() {
if(this.x == 1){
while (x<10) {
x++;
synchronized(StaticObjectTestLock.a){
System.out.println("A运行A wait");
try {
StaticObjectTestLock.a.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
if(this.x == 2){
while (x<10) {
x++;
synchronized(StaticObjectTestLock.b){
System.out.println("B运行,解开C");
synchronized(StaticObjectTestLock.c){
StaticObjectTestLock.c.notify();
// System.out.println("1111");
}
try {
StaticObjectTestLock.b.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
if(this.x ==3){
while (x<10) {
x++;
synchronized(StaticObjectTestLock.c){
System.out.println("C运行C wait");
synchronized (StaticObjectTestLock.a) {
// System.out.println("申请成功,C wait");
}
try {
StaticObjectTestLock.c.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
if(this.x ==4){
while (x<10) {
x++;
synchronized(StaticObjectTestLock.d){
System.out.println("D运行,解开C");
synchronized (StaticObjectTestLock.c) {
// System.out.println("解开C, D wait");
StaticObjectTestLock.c.notify();
}
try {
StaticObjectTestLock.d.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}