首页 > 代码库 > 查漏补缺
查漏补缺
查漏补缺
[1].this语句；
this语句用于构造函数之间进行相互调用。
this语句只能定义在构造函数的第一行，因为初始化要先执行。
[2].对象的初始化过程
Person p =new Person("hei",10);
1.因为new用到了Person.class，所以先找到Person.class文件加载到内存中
2.执行类中的静态代码块，如果有的话，给Person.class类进行初始化
3.在堆内存中开辟空间，分配内存地址
4.在堆内存中建立对象的特有属性，并进行默认初始化
5.对属性进行显式初始化
6.对对象进行构造代码块初始化
7.对对象进行与之对应的构造初始化
8.将内存地址赋值给内存中的p变量
[3].对象的执行过程
静态方法调用是 类名.静态方法()
静态属性调动是 类名.属性
注：类名一般省略
非静态的方法调用是 this.方法()
非静态的属性调用是 this.属性
[4]单例
1.将构造函数私有化
2.在类中提供一个本类对象
3.对外提供一个获取本类对象的方法
[5]继承对象的初始化执行过程
class Fu {
public static int fuNum = 23;
static {
System.out.println("static Fu.enclosing_method()... " + fuNum);
}
{
System.out.println("Fu.enclosing_method().... " + ++fuNum);
}
Fu() {
System.out.println("Fu.Fu()");
}
}
class Zi extends Fu {
public static int ziNum = 23;
static {
System.out.println("static Zi.enclosing_method()... " + ziNum);
}
{
System.out.println("Zi.enclosing_method()... " + ++ziNum);
}
Zi() {
System.out.println("Zi.Zi()");
}
Zi(String zi) {
System.out.println("Zi.Zi((String zi) .... " + zi);
}
}
Zi zi =new Zi();
[6]抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
[7]接口中的修饰成员符是固定的(默认的)。
成员常量:public static final
成员函数:public abstract
[8]多态中的特点
成员函数的特点：
编译时期，参阅引用类型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败
在运行期，参阅对象所属的类中是否有调用的方法。
成员变量的特点：
编译时期：参阅引用类型变量所属的类
在运行期：参阅引用类型变量所属的类
静态成员函数、静态成员变量的特点：
编译时期：参阅引用类型变量所属的类
在运行期：参阅引用类型变量所属的类
9.内部类,静态内部类,局部内部类,匿名内部类,没有实现接口和继承类的匿名内部类
内部类的特点：
内部类可以直接访问外部类的成员(外部类.this.成员)，包括私有成员。
外部类要访问内部类中的成员必须要建立内部类的对象。
package cn.soldier.oop;
public class InnerDemo {
private String name = "InnerDemo";
private static int age = 1;
InnerDemo() {
Inner inner = new Inner();
System.out.println(inner.name);
}
// 内部类
class Inner {
private String name = "Inner";
Inner() {
System.out.println(InnerDemo.this.name);// 默认InnerDemo.this.，可以忽略不写
}
}
// 静态内部类
public static class InnerStatic {
void innerStatic() {
// 只能访问外部类的静态成员
// 非静态内部类中不可以定义静态成员
System.out.println(age);
}
}
public void method() {
final int method_age = 10;
// 局部内部类
class MethodInner {
void function() {
// 不可以被成员修饰符修饰 .
// 可以直接访问外部类中的成员和引用，但是不可以访问它所在的非final变量。
System.out.println(age);
System.out.println(name);
System.out.println(method_age);
}
}
new MethodInner().function();
}
public void method_1() {
// 匿名内部类
// 1.定义匿名内部类的前提：内部类必须继承一个类或实现接口
// 2.其实内部类就是一个匿名子类对象。而且这个对象有点胖
new AbsDemo() {
void show() {
System.out.println("InnerDemo.method_1().show()+ name=" + name);
}
void show1() {
System.out
.println("InnerDemo.method_1().show1()+ name=" + name);
}
}.show();
//
new AbsDemo() {
void show() {
System.out.println("InnerDemo.method_1().show()+ name=" + name);
}
void show1() {
System.out
.println("InnerDemo.method_1().show1()+ name=" + name);
}
}.show1();
}
}
abstract class AbsDemo {
abstract void show();
}
class OuterDemo {
public static void main(String[] args) {
InnerDemo.Inner inner = new InnerDemo().new Inner();
new InnerDemo.InnerStatic().innerStatic();
new InnerDemo().method();
new InnerDemo().method_1();
// 面试题：请构造出下面的写法； *
new Method().method().method();
Method.method().method();
// 分析如下：
// Method类中有一个静态方法method()
// method()这个方法运算后返回结果是一个对象，而且是一个静态匿名类对象，
// 改静态匿名类对象继承一个类或实现一个接口，该类或接口里面有一个method()方法。
// 面试题：
new Object() {//这是Object子类对象，是没有实现接口和继承类的匿名内部类对象
public void function() {
System.out.println("OuterDemo.main()");
}
}.function();
}
}
class Method {
static class _Inner implements Imethod {
public void method() {
System.out.println("Method._Inner.method()，呵呵");
}
}
static _Inner method() {
return new _Inner();
}
}
interface Imethod {
abstract void method();
}
10.
Trowable
|--Error
|-- ...
|--Exception
|--ApplicationException
|--PrintException
|--ArithmeticException
|--ArrayIndexOutOfBoundsException
|--RuntimeException
|-- ...
异常声明 throws
//throws 关键字声明了该功能有可能会出现问题。需要调用者处理。
void show() throws Exception{}
异常声明 throw
void show() throws Exception{
if(true){
throw new RuntimeException();
}
}
throws 与 throw 的区别
throws 定义在函数上 ，后面跟的是异常类，可以多个以逗号隔开。
throw 定义在函数中 ，后面跟的是异常对象。
RuntimeException 及其子类 如果在函数里被抛出可以不用再函数声明。
|--ArithmeticException
|--NullPointerException
|--IndexOutOfBoundsException
|-- ...
之所以不用声明，是因为该异常的发生，不需要让调用者处理。当发生异常时，
设计者希望程序停止，因为出现了无法继续运算的情况。希望通过程序停止后，
使用者对该问题进行修正。
异常在子父类覆盖中的处理。
1.子类覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者改异常的子类。
2.如果父类方法抛出了多个异常，那么子类在覆盖该方法是，只能抛出父类异常的子集(比父类少或相等)。
3.如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法是，也不可抛出异常，也就是说，如果子类方法发生了异常，只能自己消化不能抛出。
finally 只有一种情况不会执行，
当执行到 System.exit(0);finally{}时不会执行。
自定义异常
继承Exception
或者RuntimeException
//1.具备可抛性，2，具备操作异常的共性方法。
Class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}
11.多线程
多线程的线程安全问题：
当多个语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分执行完，另一个线程参与进来执行，导致共享数据的错误。
解决线程安全问题，保证共享数据的操作是线程同步的。
同步的前提：1.一个进程中，必须由两个或者两个以上的线程。
2.多个线程使用的是同一个锁
同步函数的锁是this
静态同步函数的锁是Class对象
死锁问题：同步中嵌套同步，锁不同
public class ThreadDemo {
public static void main(String[] args) {
new Thread(new Testlock(true)).start();
new Thread(new Testlock(false)).start();
}
}
class Testlock implements Runnable {
private boolean flag;
Testlock(boolean flag) {
this.flag = flag;
}
public void run() {
if (flag) {
synchronized (Mylock.locka) {
System.out.println("if locka");
synchronized (Mylock.lockb) {
System.out.println("if lockb");
}
}
} else {
synchronized (Mylock.lockb) {
System.out.println("else lockb");
synchronized (Mylock.locka) {
System.out.println("else locka");
}
}
}
}
}
class Mylock {
static Object locka = new Object();
static Object lockb = new Object();
}
线程间通讯
wait()、notify()、notifyAll()为什么要定义在Object类中？
1.这些方法存在于同步中。
2.使用这些方法是必须要标识所属的同步锁。
3.锁是可以是任意对象，所以任意对象调用的方法一定要定义在Object类中。
wait()和sleep()有什么区别
wait释放资源，释放锁
sleep释放资源，不释放锁
package cn.soldier.oop;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;//创建Thread，小秀一手public class ThreadDemo { public static void main(String[] args) { new TestThread("逗比 ").start(); new TestThread("呵呵 hehe").start(); // for (int i = 0; i < 100; i++) { System.out.println("ThreadDemo.main() -------- " + i); } }}class TestThread extends Thread { TestThread(String name) { super(name); } @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(this.getName() + "-------TestThread.run() -------- " + i); } }}// 实现Runnable接口，使用synchronized解决多个线程操作共享数据的安全问题public class ThreadDemo { public static void main(String[] args) { TickeRunnable tickeRunnable = new TickeRunnable(); new Thread(tickeRunnable).start(); new Thread(tickeRunnable).start(); }}// class TickeThread extends Thread {class TickeRunnable implements Runnable { private int tick = 100; Object obj = new Object(); public void run() { boolean flag = true; while (flag) { synchronized (obj) { if (tick > 0) { try { Thread.sleep(100); } catch (InterruptedException e) { } System.out.println("Ticke: " + tick-- + "号，被 " + Thread.currentThread().getName() + " 卖了"); } else { flag = false; } } } }}public class ThreadDemo { public static void main(String[] args) { Cus cus = new Cus(); new Thread(cus).start(); new Thread(cus).start(); }}class Bank { private int sum; public void add(int n) { synchronized (this) { sum = sum + n; System.out.println(Thread.currentThread().getName() + " Bank.add()--- sum=" + sum); } }}class Cus implements Runnable { private Bank bank = new Bank(); public void run() { for (int i = 0; i < 3; i++) { bank.add(100); } }}// 延迟加载的单例模式class Single { private static Single s = null; private Single() { } public static Single getInStance() { if (s == null) { // 这是关键，减少同步次数，提高效率 synchronized (Single.class) { // 锁。该类所属的字节码文件对象 if (s == null) { s = new Single(); } } } return s; }}// 饿汉试单例模式class Single1 { private static final Single1 s = new Single1(); private Single1() { } public static Single1 getInStance() { return s; }}// 死锁public class ThreadDemo { public static void main(String[] args) { new Thread(new Testlock(true)).start(); new Thread(new Testlock(false)).start(); }}class Testlock implements Runnable { private boolean flag; Testlock(boolean flag) { this.flag = flag; } public void run() { if (flag) { synchronized (Mylock.locka) { System.out.println("if locka"); synchronized (Mylock.lockb) { System.out.println("if lockb"); } } } else { synchronized (Mylock.lockb) { System.out.println("else lockb"); synchronized (Mylock.locka) { System.out.println("else locka"); } } } }}class Mylock { static Object locka = new Object(); static Object lockb = new Object();}public class ThreadDemo { public static void main(String[] args) { Resource resource = new Resource(); Producer producer = new Producer(resource); Consumer consumer = new Consumer(resource); new Thread(producer).start(); new Thread(consumer).start(); new Thread(producer).start(); new Thread(consumer).start(); }}class Resource { private String name; private int count = 1; private boolean flag = false; public synchronized void set(String name) { while (flag) { try { this.wait(); } catch (Exception e) { } } this.name = name + "--" + count++; System.out.println(Thread.currentThread().getName() + "--生产者--" + this.name); flag = true; this.notifyAll(); } public synchronized void out() { while (!flag) { try { this.wait(); } catch (Exception e) { } } System.out.println(Thread.currentThread().getName() + "--------消费者-------" + this.name); flag = false; this.notifyAll(); }}class Producer implements Runnable { private Resource resource; Producer(Resource resource) { this.resource = resource; } public void run() { while (true) { resource.set("逗比"); } }}class Consumer implements Runnable { private Resource resource; Consumer(Resource resource) { this.resource = resource; } public void run() { while (true) { resource.out(); } }}public class ThreadDemo { public static void main(String[] args) { Resource resource = new Resource(); Producer producer = new Producer(resource); Consumer consumer = new Consumer(resource); new Thread(producer).start(); new Thread(consumer).start(); new Thread(producer).start(); new Thread(consumer).start(); }}class Resource { private final Lock lock = new ReentrantLock();// 拿到锁 private final Condition condition_producer = lock.newCondition();// 生产者的监视器 private final Condition condition_consumer = lock.newCondition();// 消费者的监视器 // private String name; private int count = 1; private boolean flag = false; public void set(String name) throws InterruptedException { lock.lock(); try { if (flag) condition_producer.await(); this.name = name + "--" + count++; System.out.println(Thread.currentThread().getName() + "--生产者--" + this.name); flag = true; condition_consumer.signal(); } finally { lock.unlock(); } } public void out() throws InterruptedException { lock.lock(); try { if (!flag) condition_consumer.await(); System.out.println(Thread.currentThread().getName() + "--------消费者-------" + this.name); flag = false; condition_producer.signal(); } finally { lock.unlock(); } }}class Producer implements Runnable { private Resource resource; Producer(Resource resource) { this.resource = resource; } public void run() { while (true) { try { resource.set("逗比"); } catch (InterruptedException e) { e.printStackTrace(); } } }}class Consumer implements Runnable { private Resource resource; Consumer(Resource resource) { this.resource = resource; } public void run() { while (true) { try { resource.out(); } catch (InterruptedException e) { e.printStackTrace(); } } }}
查漏补缺