[java基础]复习 java三大特性，异常，接口，String

• 继承
  
  关键字extends
  
  继承是为了不同的实现（龙生九子，各不相同）
  
  单继承，一个类最多只能有一个父类
  
  除了私有的外，子类可以访问父类的方法、属性。
  
  new过程中，父类先进行初始化，可通过super调用父类相应的构造方法，没有使用super的情况下，调用父类的默认构造方法
  
  防止继承使用final关键字
• 多态
  
  子类对象可以赋值给父类引用变量；但是执行的时候调用的却是子类的实现。
• 重载与重写
  
  重写发生在子类，主要是为了和父类不一样的实现;
  
  重载发生在方法之间，主要是为了适应不同的入参类型、数量。
  
  重写发生在编译期间，而重载发生在运行期间。
• 类加载的过程
  
  动态加载，用到加载，加载的时候，如果父类已经加载，则直接加载；否则先加载父类。
• java内存
  
  内存分为栈和堆，栈存放函数的局部变量，而堆存放动态分配的对象，还有一个内存区，存放类的信息，这个区在Java中称为方法区。例如A a = new A(); new A() 出的对象在堆，而A a 变量存在栈；A 的一些信息 方法什么的都在方法区。
  
  JVM为了提升性能和减少内存开销，避免字符串的重复创建，其维护了一块特殊的内存空间，这就是我们今天要讨论的核心，即字符串池（String Pool）。字符串池由String类私有的维护
• 接口
  
  关键字interface,implements ;可以实现多个接口，使用逗号
  
  接口里的方法名都是public的，写不写修饰符都一样。
  
  Java8之前不能写方法体。Java8 有个例外 可以使用default关键字写方法体；

public interface BaseService {
    default void sayHello(){
        System.out.println("helo");
    }
}
public class BaseServiceImpl implements BaseService {

    public static void main(String[] args) {
        BaseService baseService = new BaseServiceImpl();
        baseService.sayHello();
    }
}

• 用来判断一个对象是否实现了某接口？
  
  java使用instanceof，js 使用typeof
• 抽象类
  
  关键字 abstract ,可以被继承，没有构造函数。
  
  通常抽象类搭配接口使用，抽象类提供默认实现，类似与java8之后接口的方法声明用default声明写方法体一样，而接口声明功能；
  
  例如：

public interface BaseService {
    void sayHello();
}
/**
 * 默认实现抽象类
 */
public abstract class MyService {
    public void sayHello(){
        System.out.println("my hello");
    }
}
public class BaseServiceImpl extends MyService implements BaseService {

    public static void main(String[] args) {
        BaseService baseService = new BaseServiceImpl();
        baseService.sayHello();
    }
}

• 异常
  
  所有的异常类都有一个父类Throwable，Throwable 两大子类（得力干将） Error\Exception;如下：

public class MyException {
    public static void main(String[] args) {
        int s = testExcep();
        System.out.println("返回值："+s);
    }
    private static int testExcep() {
        int a = 0;
        try {
            a = 9/0;
            //return a;  //返回值为9，去掉return ,a的值在finally 里被修改，如果finally 里有return则返回8，没有return 就在这里直接返回，除非产生异常，没有执行return
        }catch (Exception e){
            System.out.println(e.getMessage());
            a= 7;
            return a; //catch 里的return会 finally 里的return 挤掉
        }finally {
            System.out.println("执行");
            a = 8;
            //return a; //无论之前有没有return ,都会执行finally里的return；如果finally 里没有return ,这return 在哪，就返回最近的值；
        }
        return a;
    }
}

Try(这里创建的对象自动关闭，比如inputStream.){..}catch{...}finally{释放资源}

• String ,StringBuffer,StringBuilder
  
  String类也是不可变类，即对象一旦创建，就没有办法修改了。String类也声明为了final，不能被继承，内部char数组value也是final的，初始化后就不能再变了
  
  https://www.cnblogs.com/cold-windy/p/11514977.html 讲字符串的存储
  
  StringBuffer线程安全的，而StringBuilder 是线程不安全的，底层实现都是char[] ,StringBuffer之所以线程安全，是因为重写的append()方法，ensureCapacity（）等加了synchronized：如下

@Override
    public synchronized StringBuffer append(CharSequence s) {
        toStringCache = null;
        super.append(s);
        return this;
 }

底层实现是char[],初始容量16；

StringBuilder线程不安全，因为没加锁。

• +和+= 的区别
  
  +和+= 都是java编译器支持的运算符，会转化成StringBuilder进行处理，所以拼接底层都是使用append()方法。
• 既然+ 或者是+= 都是通过StringBuilder实现的，那么还有必要去使用StringBuilder吗？
  
  如果只是简单的拼接，使不使用StringBuilder差别不大。但是如果数量大且循环拼接的话，差距就很明显，因为使用StringBuilder就只需要一次对象，而如果使用+ 或者+= 的话，等同于每循环一次，编译器每遇到一个 + 就new StringBuiler(),所以会耗费大量时间。
• 说到string 就必须谈的equals(str)以及==？
  
  equals 主要用来比较内容，如果是引用类型的话，还需要比对hashCode，而 == 主要比较基础数据类型（比的是内存地址）。
  
  hashCode和equals方法联系密切，对两个对象，如果equals方法返回true，则hashCode也必须一样。反之不要求，equal方法返回false时，hashCode可以一样，也可以不一样，但应该尽量不一样。hashCode的默认实现一般是将对象的内存地址转换为整数，子类如果重写了equals方法，也必须重写hashCode。
• 字节编码

Charset charset = Charset.forName("utf-8");//import java.nio.charset.Charset;