【java每日知识3.1】

2.26

1. hashMap在单线程中使用大大提高效率，在多线程的情况下使用hashTable来确保安全。hashTable中使用synchronized关键字来实现安全机制，但是synchronized是对整张hash表进行锁定即让线程独享整张hash表，在安全同时造成了浪费。concurrentHashMap采用分段加锁的机制来确保安全
2. 容器类有两个接口Map和Colletion，显然HashMap实现自Map接口。
3. Arrays.asList方法返回的这个List的实现类是java.util.Arrays.ArrayList这个类(而不是java.util.ArrayList)。
4. D正确。SimpleDateFormal类原文复制：Date formats are not synchronized. It is
   recommended to create separate format instances for each thread. Ifmultiple threads access a format concurrently, it must be synchronized externally.

math.floor() ——返回为double，小于参数的最大整数
math.round()——返回为int，参数加0.5，小于这个数的最大整数
long = long int

final修饰的类为最终类，不能被继承;
final修饰的方法可以被继承和重载，但不能被重写
final修饰的变量不能被修改，是个常量
finalize与c++中的析构函数有所区别，
子类可以覆盖该方法来实现资源清理工作，gc在回收对象之前调用该方法

public Test() throws RepletException {
try { System.out.println(“Test this Project!”) }catch (Exception e) {
throw new Exception(e.toString());
注意throws是写在方法上，申明要抛出的异常。throw是抛出异常。

3.1

正则表达式

\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\f 匹配一个换页符。等价于 \x0c 和 \cL。
\n 匹配一个换行符。等价于 \x0a 和 \cJ。
\r 匹配一个回车符。等价于 \x0d 和 \cM。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\t 匹配一个制表符。等价于 \x09 和 \cI。
\v 匹配一个垂直制表符。等价于 \x0b 和 \cK。
\w 匹配字母、数字、下划线。等价于’[A-Za-z0-9_]’。
\W 匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。

接口

abstract只能修饰类和方法

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

运行时常量池

多态

父类的引用可以直接指向子类对象（向上转型），而反之不可，如果子类引用需要指向父类对象，则需要强制转换，向下转型。
Base base=new Son(); 是多态的表示形式。父类对象调用了子类创建了Son对象

继承关键字extends

在Java中继承是通过extends关键字来描述的，而且只允许继承自一个直接父类
类都是单继承，接口可以继承多重继承多个接口。
java的子类只可以继承一个抽象类（abstract）（ √）
java的子类继承类使用extends关键字，继承多个类依次列出 （×）

• 构造器？导出类是什么？
  导出类就是子类，基类就是父类
  构造器就是构造函数
  class Test {
  Test() {
  //构造函数体
  }
  }
  子类调用父类构造函数时，使用super()

• 多种混合计算时，自动将所有数据类型转换为容量最大的一种数据类型。所以都转为float类型。
  public class Demo {
  public static void main(String args[]) {
  String str1 = new String(“hello”);
  String str2 = new String(“hello”);
  String str3 = “hello”;
  String str4 = “hello”;
  String str5 = “he”+“llo”;
  String str6 = “he”;
  String str7 = “llo”;
  System.out.println(str1str2); // false
  System.out.println(str1str3); // false
  System.out.println(str3str4); // true
  System.out.println(str3"hello"); // true
  System.out.println(str4==(str6+str7)); // true false
  }
  }

• String str1 = new String(“hello”);
  这种方式创建的字符串，和正常创建对象一样，保存在【堆区】。

• String str3 = “hello”;
  这种方式创建的字符串，保存在【字符串常量区】。

String str1= “hello”, String str2=“he”+“llo”;
str1str2; true
str1.equals(str2); true
String str3= “he”+a;String a=“llo”;时str1str3返回的为false. str1.equals(str2);返回true
之所以str1str2返回true是因为两者都是在字符串【常量池】中（由于初始化就会在此区域分布内存）而常量池中的有个与栈区类似的特性，就是当str2指向的常量在常量区已存在时，他不会创建新的内存空间来存此常量，而是指向已有常量的内存（应该是以此节约空间），此时str1与str2这两个引用变量的值都是存"hello"的内存空间地址，但是String str3= “he”+a;String a=“llo”;时str1str3返回的为false，是因为：str1指向的hello在编译期一如既往的还是分配在常量区内，a指向的llo也在常量区，虽然str3也是初始化但是编译器无法判断a这货到底是什么个情况，进而不会将str3的等号右侧声明在常量区内，而是在通过构造时在堆区中的【非常量池】外的内存中声明，至此str3与str1不止是分配内存的时期不同（一个在编译期，一个在运行期）而且在内存空间的区域也不同，上面最高票答案只区分了时间没区分空间。

StringBuffer和StringBuilder的区别

StringBuffer和StringBuilder类的区别也是如此，他们的原理和操作基本相同，区别在于StringBufferd支持并发操作，线性安全的，适合多线程中使用。 StringBuilder不支持并发操作，线性不安全的，不适合多线程中使用。

static final abstract 修饰方法

static修饰方法，方法属于类本身，可以类名调用。【调用：类名.静态方法名 对象名.静态方法名】
正常的实例方法，公有方法，必须实例化对象才可以调用。
final修饰方法，方法不可被重写，但是可以被重载。
abstract修饰方法，方法不能有方法体。abstract修饰方法，方法必须在抽象类或者接口中。
接口和抽象类不能被final修饰，因为他们需要被实现和继承

Abstract 抽象类与抽象方法：

下面哪些情况下该类一定为抽象类？
当一个类的一个或多个方法是抽象方法时（√）
当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时（√）
当一个类实现多个接口时（×）
当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时（√）
我建一个接口，然后一个类implements这个接口，并且不能为任何抽象方法提供任何细节或方法体时，这个类必须是抽象类，并override的所有方法。
在类中实现接口时，必须实现接口中所有的方法。方法的名字、返回值类型、参数的个数及类型必须与接口中的完全一致，并且必须实现接口中的所有方法。

public interface MyInterface { public void method1();}
public abstract class MyAbstractClass implements MyInterface{
	@Override
	public void method1() {   } 
}
public abstract class ChildAbstractClass extends MyAbstractClass{
	@Override
	public abstract void method1();
}

1、当一个类包含一个或多个抽象方法，该类必须被限定为抽象的（否则编译器会报错）
2、一个没有任何抽象方法的类也可以是抽象类（当想阻止产生这个类的对象时，可以设置为抽象类）
3、从抽象类继承的类，可能是抽象类，也可能不是。若不是，则必须为基类中的所有抽象方法提供方法定义，且可以创建该新类的对象。如果不为基类中所有抽象方法提供方法定义，那么导出类也是抽象类

• abstract方法必须在abstract类或接口中？
  一个类若有抽象方法，其本身也必须声明为抽象类；接口中的方法默认就是public abstract；综上所诉：abstract方法必须在abstract类或接口中。

• abstract类中可以有private成员吗？
  不管是成员变量，还是非抽象方法都不建议用private修饰，抽象方法是禁止使用private修饰。原因就是我们创建抽象类的目的就是要实现代码复用，方便子类继承，private修饰的虽然能被继承，但是对子类是不可见的，也就是无法直接访问使用，同时抽象类不能实例化对象，所以用private修饰的成员实际用处不大。 抽象类的中抽象方法只允许用public和默认修饰

• static方法能直接调用类里的非static属性？（×）
  在JVM中static方法在静态区，静态区无法调用非静态区属性。

Java中所有的非抽象方法都必须在类内定义（√）
Java是纯粹的面向对象语言，所有的方法都必须存在于类中。类才有封装，继承，多态的特性。

以下多线程对int型变量x的操作只有D不需要进行同步。
++x
x=y
x++
x=1
同步是害怕在操作过程的时候被其他线程也进行读取操作，一旦是原子性的操作就不会发生这种情况。因为一步到位的操作，其他线程不可能在中间干涉。另外三项都有读取、操作两个步骤，而X=1则是原子性操作。

• 静态代码块中的局部变量 与 静态成员变量
• 

1.JVM加载class文件时，就会执行静态代码块，静态代码块中初始化了一个变量x并初始化为5，由于该变量是个局部变量，静态代码快执行完后变被释放。
2.申明了两个静态成员变量x，y，并没有赋初值，会有默认出值，int类型为0，
3.执行x–操作，变量单独进行自增或自减操作x–和--x的效果一样，此时x变为了-1
4.调用MyMethod()方法，在该方法中对x和y进行计算，由于x和y都是静态成员变量，所以在整个类的生命周期内的x和y都是同一个

集合数据类型

String为引用数据类型

package包

包（package）是Java中描述操作系统对多个源代码文件组织的一种方式。（×）
import语句将所对应的Java源文件拷贝到此处执行。（×）
包（package）是Eclipse组织Java项目特有的一种方式。（×）
定义在同一个包（package）内的类可以不经过import而直接相互使用。（√）
1、为了更好地组织类，Java提供了包机制。包是类的容器，用于分隔类名空间。如果没有指定包名，所有的示例都属于一个默认的无名包。Java中的包一般均包含相关的类，java是跨平台的，所以java中的包和操作系统没有任何关系，java的包是用来组织文件的一种虚拟文件系统。A错
2、import语句并没有将对应的java源文件拷贝到此处仅仅是引入，告诉编译器有使用外部文件，编译的时候要去读取这个外部文件。B错
3、Java提供的包机制与IDE没有关系。C错
4、定义在同一个包（package）内的类可以不经过import而直接相互使用。

多重继承是指什么？

多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征，然而我们知道Java为了保证数据安全，它只允许单继承。但是可以通过接口和内部类实现多重继承。
Java只支持单继承，实现多重继承三种方式：（1）直接实现多个接口 （2）扩展(extends)一个类然后实现一个或多个接口 （3）通过内部类去继承其他类

重写与重载的区别？

重载发生在一个类中,同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者二者都不同)则视为重载;重写发生在子类与父类之间,重写要求子类被重写方法与父类被重写方法有相同的参数列表,有兼容的返回类型,比父类被重写方法更好访问,不能比父类被重写方法声明更多的异常(里氏代换原则)。重载对返回类型没有特殊的要求,不能根据返回类型进行区分。”

==与equals的区别？

==
两边都是包装类
类型相同
类型不同 编译错误
一边是包装类，一边是基本数据类型
自动拆箱(即使是不同的数据类型，也会自动拆箱)
equals
参数是基本数据类型，自动装箱成为包装数据类型
参数是不同的包装类型，先比较类型，输出false

java进程的JVM参数配置

抽象类；抽象类的子类；抽象方法

多线程问题：sleep() wait() yield()

运行时常量池：
1、受方法区大小的影响
2、存放编译时期生成的各种字面量
3、存放编译时期生成的符号引用
不受栈区大小的影响

• CountDownLatch 允许一个线程或多个线程等待特定情况，同步完成线程中其他任务。举例：百米赛跑，就绪运动员等待发令枪发动才能起步。
• CyclicBarrier 和CountDownLatch一样都可以协同多个线程，让指定数量的线程等待期他所有的线程都满足某些条件之后才继续执行。举例：排队上摩天轮时，每到齐四个人，就可以上同一个车厢。
• 链接：https://www.nowcoder.com/questionTerminal/c39e3eb52191404789349ec5b21476cf
  来源：牛客网
• Semaphore 通常我们叫它信号量， 可以用来控制同时访问特定资源的线程数量，通过协调各个线程，以保证合理的使用资源。
• future表示一个可能还没有完成的异步任务的结果，针对这个结果可以添加Callback以便在任务执行成功或失败后作出相应的操作。

类中实现接口 implements

1、必须实现接口中所有的方法。
在实现类中实现接口时，方法的名字、返回值类型、参数的个数及类型必须与接口中的完全一致，并且必须实现接口中的所有方法。

2、接口实现类相当于子类，子类的访问权限是不能比父类小的。
接口中所有方法默认都是public，至于为什么要是public，原因在于如果不是public，那么只能在同个包下被实现，可访问权限就降低很多了，那么在实现类中，实现的类相当于子类，子类的访问权限是不能比父类小的，而在java中一个类如果没有权限的修饰符，默认是friendly(同一个包内的其它类才可访问)，所以在实现类中一定要写public

java多线程

wait()：等待时线程别人可以用。
sleep()：等待时线程还是自己的，别人不能用。
yield()：释放锁，同优先级的其他线程有机会获得锁。

jvm内存结构

堆 栈

程序计数器

PC register：记录当前程序运行到哪里了

方法区

线程共有的
存放运行时常量池、类

本地方法栈

实现其他语言的运行


类和对象是存放在堆中，栈里存放对象的引用地址。
String在JAVA中也是对象。

GC垃圾回收

栈里面的内容在程序运行后就删除了，而堆中的内容需要使用GC来回收

GCroot直接相连的有：栈、方法区（全局变量）、本地方法区
清理算法：
1、标记-清理算法。 会出现内存碎片
2、标记-整理算法。删了第一个，后面的全部往前顶【减少内存碎片】代价大
3、复制算法 需要2倍内存
12用于OldGC，3用于YoungGC

java口诀歌

青花瓷（Java版）

J D K 和J R E 莫要混淆去
环境变量的配置有时让人迷
初学的人莫贪图上来I D E
先用J D K +文本编辑器

面向对象仨特点一定要牢记
封装继承和多态一个不能离
接口为多重继承
抽象类一定要有实例

O b je c t呀 所有类爹地
package在类中只能有唯一
注释命名时要既规范又明晰
就当为好程序员伏笔（这样程序员才是好样滴）
G U I 不是鬼 千万别恐惧
四大布局管理 多练才熟悉
勤能补拙熟能生巧到考试时
你眼带笑意
----------------------------
三整两浮一布尔再加字节符
基本数据Byte数了然于心底
碰到异常一定记得try/catch
要打包发布使用jar命令

线程何时被调用全看调度器
睡眠同步和死锁使用要仔细
网页中Applet
独立程序Application

O b je c t呀 所有类爹地
package在类中只能有唯一
注释命名时要既规范又明晰
就当为好程序员伏笔（这样程序员才是好样滴）

G U I 不是鬼 千万别恐惧
四大布局管理 多练才熟悉
勤能补拙熟能生巧到考试时
你眼带笑意