前言

上学期Java没好好学，重新学习下，定期学完整理下笔记，做个总结。

• 如果有错误欢迎指出

编译流程

.java -> .class -> 执行.class

jvm < jre < jdk

创建String流程

• 两种方式创建区别

    String a = "hello";
    String b = "hello";
    System.out.println(a==b);
  
    String c = new String("hello");
    String d = new String("hello");
    System.out.println(c==d);

    true
    false

原因分析

虚拟机内存划分(涉及本次)

对于栈和常量池中的对象可以共享，对于堆中的对象不可以共享。栈中的数据大小和生命周期是可以确定的，当没有引用指向数据时，这个数据就会自动消失。堆中的对象的由垃圾回收器负责回收，因此大小和生命周期不需要确定，具有很大的灵活性。
而对于字符串来说，其对象的引用都是存储在栈中的，如果是编译期已经创建好（即指用双引号定义的）的就存储在常量池中，如果是运行期（new出来的对象）则存储在堆中。对于equals相等的字符串，在常量池中是只有一份的，在堆中则有多份。

创建 String，先在 常量池中寻找，如果有，则直接使用，如果无，则创建后放入 常量池，并使用

1. 使用 String str = ""创建在 栈中创建 str，指向 常量池（如果 常量池中无则创建，否则直接使用）
2. 使用 new创建在 堆中创建一个 常量池对象的拷贝对象（如果 常量池中无则创建，否则直接使用）。栈中创建 引用指向 堆中拷贝对象。

3. 区别：

   1. 如果使用字面量，则从 常量池中找
   2. 如果使用 new，则从 堆中创建，而 堆又会从 常量池中找
   3. 如果想 new后从 常量池中获取，可以使用 inter()。如上代码。
      System.out.println(c.intern() == a); true

例题：

• String str = new String("hello")创建了多少个对象？

  1. 如果 常量池中不存在：则产生2个 对象和1个 引用
  2. 如果之前存在，则产生1个 对象和1个 引用
• String str = new String("a" + "b")产生多少个对象？（常量池为空，不含引用）4个 （常量池中）a + b + ab + 堆中1个
• String str = new String("a") + "a"产生多少个对象？（常量池为空，不含引用）
  3个 （常量池中）a + aa + 堆中1个

访问修饰符

继承/代码块/重写和重载

• 子类继承父类：private，构造方法 是不能被继承的。但是 子类可以调用父类构造 super

• 代码块：

  1. 静态代码块：永远只执行一次。初始化。
  2. 普通代码块：每次在 被创建之前执行。

  3. 执行顺序：

     1. 父类static
     2. 子类static
     3. 父类普通
     4. 父类构造
     5. 子类普通
     6. 子类构造

重写和重载(Override/Overload)

抽象类/final

抽象类

class abstract t {
    public abstract void a();
}

• 抽象类不能被实例化，因为可能存在 抽象方法，而 抽象方法没有 方法体
• 抽象方法必须在 抽象类中。
• 抽象类中，并不一定包含 抽象方法

final

多态

父类 引用对象名 = new 子类()`double d = 10 //大范围类型 = 小范围类型`

• 多态实现方法：

  1. 方法重载
  2. 方法重写
  3. 使用 父类作为方法的 形参
  4. 使用 父类作为方法的 返回值
• 判断父子类：对象 instanceof 类型

接口

public interface Person {
    //1.属性全部是static final类型
    //2.方法全是public abstract
    void a();
    int b();
}

接口 比 抽象类 更进一步 "抽象"

• 继承：is a接口：has a
• 父类 -> 子类 -> A extends B{}接口 -> 实现类 -> A implements B{}
• 类：单继承；接口：接口之间可以相互继承，多继承。
• 接口不存在 构造方法
• 当 类实现 接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。
• 接口回调：以后填坑。

值传递/引用传递

• 基本类型作为参数传递，值不变。
• 引用类型作为参数传递，值改变。

Lambda入门(Java8)

• 作用：简化代码

• 组成：

  • 逗号隔开的参数列表(a, b, c)
  • 箭头符号 ->
  • 方法体(λ代码块)
• 要求重写的 接口，抽象类中 有且只有一个 抽象方法
• 函数式接口：@FunctionalInterface 有且只有一个抽象方法
• lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。
• 如果主体包含了一个语句，就不需要使用大括号。也不需要引号

    public static void main(String[] args) {
        new Thread(
                () -> System.out.print("hello")
        ).start();
    }

内部类

套娃有点脑壳痛QAQ

分类：

• 成员内部类

  • 内用外，随意
  • 外用内，需要内部类对象
  • 外部类名称.内部类名称 对象名 = new 外部类名称().内部类名称();

• 局部内部类

  • 定义在方法内部

    class name {
        //没有权限修饰符
    }

• 匿名内部类

  • 实现：

    new Interface()  {
    // Anonymous  class body  goes  here
    }

  • 接口名 就是 匿名内部类要实现哪个 接口
  • 创建的 类只能使用一次。

多线程

创建线程：

都要重写 run方法

1. MyThread继承Thread(本质也是实现Runnable)

   public class tmp {
       public static void main(String[] args) {
           MyThread m = new MyThread();
           m.start();
       }
   }
   
   class MyThread extends Thread {
       public void run() {
           // TODO Auto-generated method stub
           System.out.print("hello");
       }
   }

2. 实现Runnable接口

   public class tmp {
       public static void main(String[] args) {
           dou d = new dou();
           Thread t = new Thread(d);
           t.start();
       }
   }
   
   class dou implements Runnable {
       @Override
       public void run() {
           // TODO Auto-generated method stub
           System.out.print("hello");
       }
   }

线程同步

• 多线程访问了共享的数据，会产生线程安全问题。

• 如何解决：

  • 同步代码块

    Object obj = new Object()
    synchronized(obj) {
        //访问共享数据的代码
    }

  • 同步方法

    public synchronized void payTicket() {
        if()
            //卖票
    }

  • 锁机制

    private final ReentrantLock lock = new ReentrantLock();
    
    public void demo() {
        lock.lock();
        try {
    
        } finally {
            lock.unlock();
        }
    }

异常

• 运行时异常：代码在编辑时，不报错，运行时才报错。语法上，可选择处理。
• 检查异常：代码在编辑时，报错。编辑时必须处理。
• 关键字：try catch finally throws throw
• 如果 try中出现异常，则跳过异常后代码，跳转到 catch中

try catch

当前方法能够处理。

throws

当前方法不能处理，上交到 方法调用处 处理。

• main函数 再向上抛出 给 JVM

finally

无论正常，异常，始终执行的代码。

• 即使遇到return，也会执行。
• 除非虚拟机关闭，不会执行。
  System.exit(0)是正常退出程序，而System.exit(1)或者说非0表示非正常退出程序

throw

声明异常
throw new MyException("msg");

自定义异常

• 继承Exception，调用 Super(msg)

常用方法

• e.printStackTrace();
• e.getMessage();

版权属于：moluuser

本文链接：https://archive.moluuser.com/archives/15/

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。