Java基础知识

对 Java 多态的理解

面向对象编程的三大特性：封装、继承、多态。

• 封装：隐藏类的内部实现机制。

• 继承：重用父类代码，为多态做铺垫。

• 多态：程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定。

实现多态的三个必要条件：继承、重写、向上转型。

• 继承：在多态中必须存在有继承关系的子类和父类。

• 重写：子类对父类中的某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

• 向上转型：将父类引用指向子类对象，只有这样，该引用才具备调用子类方法的能力。

实现形式：

• 基于继承实现的多态。

• 基于接口实现的多态。

父类的静态方法可以被子类继承，但是不能被子类重写。当子类声明了一个与父类相同的静态方法时，只能称为隐藏。

在Java中，分为基本数据类型和复合数据类型，基本数据类型包括byte、short、char、int、long、float、double、boolean这八种。

• 对于基本数据类型，==比较的是它们的值。

• 对于复合数据类型，比较的是它们在内存中的存放地址，即比较的是否是同一个对象。

//Value 替换的条件//条件1：hash 值完全相同//条件2：key 指向同一块内存地址 或者 key 的 equals 方法返回为 true

(e.hash == hash && ((k = e.key) == key || key.equals(k)))

public class TestString {

    public static void main(String[] args) {

    String s1 = "Monday";

    String s2 = new String("Monday");

    if (s1 == s2)

    System.out.println("s1 == s2");

    else

    System.out.println("s1 != s2");

    if (s1.equals(s2)) System.out.println("s1 equals s2");

    else

    System.out.println("s1 not equals s2");

    }

    }

我们将s2用new操作符创建

    程序输出：

    s1 != s2

    s1 equals s2

    说明：s1 s2分别引用了两个"Monday"String对象

String、StringBuilder、StringBuffer 的区别

对比

• String中的是常量数组，只能被赋值一次。

• 在编译阶段就能够确定的字符串常量，没有必要创建String/StringBuffer对象，直接使用字符串常量的+效率更高。

• StringBuffer中的value[]是一个很普通的数组，而且可以通过append方法将新字符串加入到末尾，改变内容和大小。

• StringBuffer允许多线程操作，其很多方法都被关键字synchronized修饰，而StringBuilder则不是，如果不考虑线程安全，StringBuilder应该是首选。

• 不停地创建对象是程序低效的原因，因此我们应该尽可能保证相同的字符串在堆中只创建一个String对象。

• 当调用String的intern时，如果常量池已经有了当前String的值，那么返回这个常量指向的地址；如果没有，则将String值加入到常量池中。

String s1 = "abc";

String s2 = "abc";

s1和s2指向常量池中的同一个对象abc，如果String是可变类，s1对其的修改将会影响到s2。

如果两个对象equals，Java运行时环境会认为他们的hashcode一定相等。

如果两个对象不equals，他们的hashcode有可能相等。

如果两个对象hashcode相等，他们不一定equals。

如果两个对象hashcode不相等，他们一定不equals。

StringBuilder:字符串变量（线程不安全） 确保单线程下可用，效率略高于StringBuffer。

finalize:类的方法,垃圾回收之前会调用此方法,子类可以重写finalize()方法实现对资源的回收。

Serializable 和Parcelable 的区别

Serializable Java 序列化接口 在硬盘上读写 读写过程中有大量临时变量的生成，内部执行大量的i/o操作，效率很低。

Parcelable Android 序列化接口 效率高 使用麻烦 在内存中读写（AS有相关插件 一键生成所需方法） ，对象不能保存到磁盘中

哪些情况下的对象会被垃圾回收机制处理掉

1.所有实例都没有活动线程访问。

2.没有被其他任何实例访问的循环引用实例。

3.Java 中有不同的引用类型。判断实例是否符合垃圾收集的条件都依赖于它的引用类型。

要判断怎样的对象是没用的对象。这里有2种方法：

1.采用标记计数的方法：

给内存中的对象给打上标记，对象被引用一次，计数就加1，引用被释放了，计数就减一，当这个计数为0的时候，这个对象就可以被回收了。当然，这也就引发了一个问题：循环引用的对象是无法被识别出来并且被回收的。

2.采用根搜索算法：

从一个根出发，搜索所有的可达对象，这样剩下的那些对象就是需要被回收的。

等待对象的同步锁,需要获得该对象的同步锁才可以调用这个方法,否则编译可以通过，但运行时会收到一个异常：IllegalMonitorStateException。

调用任意对象的 wait() 方法导致该线程阻塞，该线程不可继续执行，并且该对象上的锁被释放。

唤醒在等待该对象同步锁的线程(只唤醒一个,如果有多个在等待),注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

调用任意对象的notify()方法则导致因调用该对象的 wait()方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行） 

如何实现线程同步

1、synchronized关键字修改的方法。2、synchronized关键字修饰的语句块3、使用特殊域变量（volatile）实现线程同步

抽象类和接口区别：

抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。

接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。

参数	抽象类	接口
默认的方法实现	它可以有默认的方法实现	接口完全是抽象的。它根本不存在方法的实现
实现	子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。	子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器	抽象类可以有构造器	接口不能有构造器
与正常Java类的区别	除了你不能实例化抽象类之外，它和普通Java类没有任何区别	接口是完全不同的类型
访问修饰符	抽象方法可以有public、protected和default这些修饰符	接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法	抽象方法可以有main方法并且我们可以运行它	接口没有main方法，因此我们不能运行它。
多继承	抽象方法可以继承一个类和实现多个接口	接口只可以继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
添加新方法	如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。	如果你往接口中添加方法，那么你必须改变实现该接口的类。

final关键字不能用来抽象类和接口。

 接口中基本数据类型为static 而抽象类不是的

内部类作用

1.内部类可以很好的实现隐藏

 一般的非内部类，是不允许有 private 与protected权限的，但内部类可以

2．内部类拥有外围类的所有元素的访问权限

3.可是实现多重继承

4.可以避免修改接口而实现同一个类中两种同名方法的调用。

泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

首先finally语句在改代码中一定会执行，从运行结果来看，每次return的结果都是4（即finally语句），仿佛其他return语句被屏蔽掉了。

事实也确实如此，因为finally用法特殊，所以会撤销之前的return语句，继续执行最后的finally块中的代码

1). 静态方法和属性是属于类的，调用的时候直接通过类名.方法名完成对，不需要继承机制及可以调用。如果子类里面定义了静态方法和属性，那么这时候父类的静态方法或属性称之为"隐藏"。如果你想要调用父类的静态方法和属性，直接通过父类名.方法或变量名完成，至于是否继承一说，子类是有继承静态方法和属性，但是跟实例方法和属性不太一样，存在"隐藏"的这种情况。 

2). 多态之所以能够实现依赖于继承、接口和重写、重载（继承和重写最为关键）。有了继承和重写就可以实现父类的引用指向不同子类的对象。重写的功能是："重写"后子类的优先级要高于父类的优先级，但是“隐藏”是没有这个优先级之分的。 

3). 静态属性、静态方法和非静态的属性都可以被继承和隐藏而不能被重写，因此不能实现多态，不能实现父类的引用可以指向不同子类的对象。非静态方法可以被继承和重写，因此可以实现多态。 

成员内部类

成员内部类也是最普通的内部类，它是外围类的一个成员，所以它可以无限制的访问外围类的所有成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。

在成员内部类中要注意两点：

成员内部类中不能存在任何static的变量和方法；

成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。

静态内部类

静态内部类与非静态内部类之间存在一个最大的区别：非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。

没有这个引用就意味着：

它的创建是不需要依赖于外围类的。

它不能使用任何外围类的非static成员变量和方法。

UTF-8

UTF-16 统一采用两个字节表示一个字符，虽然在表示上非常简单方便，但是也有其缺点，有很大一部分字符用一个字节就可以表示的现在要两个字节表示，存储空间放大了一倍，在现在的网络带宽还非常有限的今天，这样会增大网络传输的流量，而且也没必要。而 UTF-8 采用了一种变长技术，每个编码区域有不同的字码长度。不同类型的字符可以是由 1~6 个字节组成。

在java 中Object是一个具体的类，但是他的设计主要是为了拓展。当我们写一个类的时候，都会对Java.lang.Object类的一些重要方法进行重写（ 改写 override），这些方法包含：hashCode(),toString(),equals(),finalize(),clone(),wait(),notify()/notifyAll() 这八个方法。

Collections.sort(list,new Comparator<Integer>(){

            @Override

            public int compare(Integer str1, Integer str2) {

                // TODO Auto-generated method stub         

                    String s1=str1+""+str2;

                    String s2=str2+""+str1;

                    return s1.compareTo(s2);

                }

            });

 

interrupt() 它基于「一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止。」思想，是一个比较温柔的做法，它更类似一个标志位。其实作用不是中断线程，而是「通知线程应该中断了」，具体到底中断还是继续运行，应该由被通知的线程自己处理。

interrupt() 并不能真正的中断线程，这点要谨记。需要被调用的线程自己进行配合才行。也就是说，一个线程如果有被中断的需求，那么就需要这样做：

1. 在正常运行任务时，经常检查本线程的中断标志位，如果被设置了中断标志就自行停止线程。

2. 在调用阻塞方法时正确处理InterruptedException异常。（例如：catch异常后就结束线程。）