自己学习用记录
java 初始化顺序
image.png
image.png
clone 方法
在函数调用或“=”时：
基本数据类型：按值传递
其他类型：按引用传递
深复制：
image.png
image.png
super.clone()用来复制基本数据类型
深复制内容需手动复制
抽象和接口
抽象类不可实例化，有一个抽象方法就是抽象类
接口中的方法只能是public abstract（可以不写或写一部分），成员变量只能是public static final
抽象类的成员变量默认为default，抽象类的抽象方法不能用private/static/native/synhronized 修饰，并必须以 : 结尾
多态
编译时多态：重载
运行时多态：重写
import java.util.Scanner;
class Father{
private int a=1;
public int b=1;
public void geta(){
System.out.println(this.a);
}
public void number(){
System.out.println("father");
}
private void number2(){
System.out.println("father");
}
}
class Child extends Father{
private int a=2;
public int b=2;
public void geta(){
System.out.println(this.a);
}
public void number(){
System.out.println("child");
}
public void number2(){
System.out.println("child");
}
}
public class Main1{
public static void main(String arg[]){
Father father=new Child();
Child child=new Child();
//测试
father.geta(); //2
System.out.println(father.b); //1 ，方法才有多态，成员变量没有
father.number(); //child，重写
//father.number2();报错,并没有重写，调用私有函数出错
child.geta(); //2
System.out.println(child.b); //2
child.number(); //child，重写
child.number2(); //child，并没有重写，调用子类的函数
}
}
内部类
1.成员内部类
import java.util.Scanner;
class Outclass {
private int a = 0;
private int b = 0;
public Outclass(int a) {
this.a = a;
Inclass onclass=new Inclass();//必须新建内部类对象来调用
onclass.print();
onclass.print2();
}
class Inclass { //内部类
private int b = 1;
public void print() {
System.out.println(a);//成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
System.out.println(b);
System.out.println(Outclass.this.b);//内部类拥有和外部类同名,需要：外部类.this.成员变量/方法
}
public void print2() {
System.out.println("private");
}
}
}
public class Main1{
public static void main(String arg[]){
Outclass outclass=new Outclass(1);
Outclass.Inclass inclass=outclass.new Inclass();//必须通过outclass对象来创建
inclass.print();
//如果成员内部类Inner用private修饰，则只能在外部类的内部访问，
//如果用public修饰，则任何地方都能访问；
//如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；
//如果是默认访问权限，则只能在同一个包下访问。
//非静态内部类不能有static成员
}
}
//输出：1 1 0 private 1 1 0
2.静态内部类
静态内部类在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类而实例化，并且它不能使用外部类的非static成员变量或者方法，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。
创建静态内部类对象的一般形式为： 外部类类名.内部类类名 xxx = new 外部类类名.内部类类名()
创建成员内部类对象的一般形式为： 外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名()
3.局部内部类
局部内部类就像是方法里面的一个局部变量一样，不能有public、protected、private以及static修饰符的。
class People{
public People() {
}
}
class Man{
public Man(){
}
public People getWoman(){
class Woman extends People{ //局部内部类
int age =0;
}
return new Woman();
}
}
4.匿名内部类
abstract class parent {
public abstract void like();
}
public class Demo {
public static void main(String[] args) {
parent pt = new parent(){
public void like(){
System.out.println("吃饭睡觉打豆豆。。。");
}
};
pt.like();
}
}
//一般使用匿名内部类的方法来编写事件监听代码,或者临时重写一个方法
final、finally、finalize区别
final：声明
finally：关闭数据库资源
finalize：垃圾回收相关
assert断言
https://www.cnblogs.com/binbang/p/6386780.html
volatile
读取变量时从内存中读取非缓存，不可替代syhronized
可以用来设置一个变量，用于立刻终止线程
image.png
instanceof
判断左边的对象是否是他右边的类的实例
result=object instanceof class
strictfp
声明的类、接口、方法保证浮点数的精度
基本数据类型
null:表明引用没有对象，对空对象做任何操作都不行,但实际是置0；
String s=null;只是定义了一个句柄，也就是说你有了个引用，但是这个引用未指向任何内存空间
String s="";这个引用已经指向了一块是空字符串的内存空间，是一个实际的东东了，所以你可以对它操作，而不用担心什么了
float c=1.4;//错误，默认为double
Float d=1.4;//错误，默认为double
boolean a =null//错误，只能二选一
Boolean a=null;//正确,但null作为if的条件会报npe
值传递和引用传递
https://www.zhihu.com/question/31203609
public class littertest {
public static void main(String arg[]){
String s1="abc";
String s2="abc";
String s3=new String("abc");
String s4=new String("abc");
System.out.println(s1==s2);//true
System.out.println(s1==s3);//false
System.out.println(s3==s4);//false
}
}
public class littertest {
public static void main(String arg[]){
changeclass aa=new changeclass();
dataclass bb=new dataclass();
dataclass cc=bb;
aa.change(bb);
int hascode1=bb.hashCode();
int hascode2=cc.hashCode();
System.out.println(bb.a);//2,值被改变
System.out.println(hascode1==hascode2);//true，证明是引用同一个内存
}
}
class dataclass {
int a=1;
}
class changeclass{
public void change(dataclass a){
a.a=2;
}
}
image.png
拆箱装箱
https://blog.csdn.net/diyinqian/article/details/78899740
public class littertest {
public static void main(String arg[]){
Integer a=144;
Integer b=144;
b=a;//去掉结果为false
System.out.println(a==b);
}
}
//结果为true，b和a的引用一致，==比较引用，equals()比较的是值(如果类没有重写equals，则比较引用)，hashCode()返回对象在内存中的地址转换的int，不同对象不同,指向同一个对象的相同。
包装类和String都是不可变类
short s=1;
s=s+1//错误,s->int,int不能再转为short
s+=1//正确，Java做了特殊处理
>> 有符号右移动，高位补0或1
>>>无符号右移动，高位补0
<< 低位补0
内存泄漏
image.png
image.png
容器和迭代器
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class littertest {
public static void main(String arg[]){
List list=new LinkedList();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
Iterator ite=list.iterator();
Iterator ite2=list.iterator();
while(ite.hasNext()) {//hasNext(),判断是否有下一个元素
String a=ite.next();
System.out.println(a);//next()取下一个元素，
}
while(ite2.hasNext()) {//对JAVA集合进行遍历删除时务必要用迭代器,会抛出ConcurrentModificationException异常
String a=ite2.next();
if(a.equals("2"))
ite2.remove();
System.out.println(a);//next()取下一个元素，
}
Iterator ite3=list.iterator();//注意如果在删除前定义，一样会抛出ConcurrentModificationException异常
while(ite3.hasNext()) {//hasNext(),判断是否有下一个元素
String a=ite3.next();
System.out.println(a);//next()取下一个元素，
}
}
}
//结果：1 2 3 4 1 2 3 4 1 3 4 ，第三次遍历去掉了2
容器：
image.png
hashmap使用注意，案例位于书150-153页
image.png
单例模式要点：
class SingletonDemo {
private static SingletonDemo instance; //1.类中定义自己
private SingletonDemo(){ //2.构造函数为private，防止调用
}
public static synchronized SingletonDemo getInstance(){//3.synchronized，线程安全，并返回自身
if(instance==null){//4.有一个if，保证实例化一次
instance=new SingletonDemo();//5.类中调用自身构造函数
}
return instance;
}
}
java中类加载时机
反射
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class reflex {
public static void main(String arg[]){
System.out.print("类测试\n");
Class clazz = null;
//1.通过类名
clazz = reflexA.class;
//2.通过对象名
//这种方式是用在传进来一个对象，却不知道对象类型的时候使用
reflexA a = new reflexA();
clazz = a.getClass();
//上面这个例子的意义不大，因为已经知道person类型是Person类，再这样写就没有必要了
//如果传进来是一个Object类，这种做法就是应该的
Object obj = new reflexA();//这里一般是函数传进来
clazz = obj.getClass();
System.out.println(clazz.getName());
//3.通过全类名(会抛出异常)
//一般框架开发中这种用的比较多，因为配置文件中一般配的都是全类名，通过这种方式可以得到Class实例
String className="reflexA";
try {
clazz = Class.forName(className);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
/////////////////////////////////////////////////////
System.out.print("方法测试\n");
//1.获取方法
// 1.1 获取取clazz对应类中的所有方法--方法数组（一）
// 不能获取private方法,且获取从父类继承来的所有方法
System.out.print("方法测试1\n");
Method[] methods = clazz.getMethods();
for(Method method:methods){
System.out.print(" "+method.getName());
}
System.out.println();
System.out.print("方法测试2\n");
// 1.2.获取所有方法，包括私有方法 --方法数组（二）
// 所有声明的方法，都可以获取到，且只获取当前类的方法
methods = clazz.getDeclaredMethods();
for(Method method:methods){
System.out.print(" "+method.getName());
//得到方法返回类型的类类型
Class returnType = method.getReturnType();
System.out.print(" "+returnType.getName());
}
System.out.println();
System.out.print("方法测试3\n");
//
// 1.3.获取指定的方法
// 需要参数名称和参数列表，无参则不需要写
Method method = null;
try {
// 对于方法public void setName(String name) { }
method = clazz.getDeclaredMethod("setName", String.class);
System.out.println(method);
// 而对于方法public void setAge(int age) { }
method = clazz.getDeclaredMethod("setAge", int.class);
System.out.println(method);
// 如果写Integer是获取不到的，因为方法的参数类型是int型
// 如果方法用于反射，那么要么int类型写成Integer： public void setAge(Integer age) { }
// 要么获取方法的参数写成int.class
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
///////////////////////////////////////////////
System.out.print("执行测试\n");
//2.执行方法
// invoke第一个参数表示执行哪个对象的方法，剩下的参数是执行方法时需要传入的参数
Object obje = null;
try {
obje = clazz.newInstance();
try {
//method.setAccessible(true);//如果执行为私有方法，不会执行，需要抑制Java的访问控制检查
method.invoke(obje,2);
} catch (InvocationTargetException e) {
e.printStackTrace();
}
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
//如果一个方法是私有方法，第三步是可以获取到的，但是这一步却不能执行
//私有方法的执行，必须在调用invoke之前加上一句method.setAccessible（true）;
}
}
class reflexA{
public static final int stfl=0;
public static int st=0;
public int publica=0;
private int privatea=0;
static{
System.out.println("static zero");
}
public static void staticmethod(){
System.out.println("staticmethod");
}
public void method(){
System.out.println("method");
}
public reflexA(){
System.out.println("structurereflexA");
}
private void privatemethod(){
System.out.println("privatemethod");
}
public void setName(String name) {
System.out.println("setName");
}
public void setAge(int age) {
System.out.println("setAge");
}
}
JAVA装饰者模式
https://www.cnblogs.com/panhouye/p/6120232.html
信号量和PV操作
https://www.cnblogs.com/lavenderzh/p/5324961.html
来自书：java程序员面试笔记宝典-何昊