Java查漏补缺

1.自动转换按从低到高的顺序转换。不同类型数据间的优先关系如下： 
低 ---------------------------------------------> 高 
byte,short,char-> int -> long -> float -> double

强制转换的格式是在需要转型的数据前加上 “( )” ，然后在括号内加入需要转化的数据类型。有的数据经过转型运算后，精度会丢失，而有的会更加精确

由低到高不需要强转

1. 只看尖括号里边的！！明确点和范围两个概念

2.
如果尖括号里的是一个类，那么尖括号里的就是一个点，比如List<A>,List<B>,List<Object>

3. 如果尖括号里面带有问号，那么代表一个范围，<? extends A>
代表小于等于A的范围，<? super A>代表大于等于A的范围，<?>代表全部范围

4. 尖括号里的所有点之间互相赋值都是错，除非是俩相同的点

5. 尖括号小范围赋值给大范围，对，大范围赋值给小范围，错。如果某点包含在某个范围里，那么可以赋值，否则，不能赋值

6. List<?>和List 是相等的，都代表最大范围

例子：

List<A> a;

List<B> b;

a!=b;

LIst<? extends A> at;

List<? extends B> bt;

at==bt;

 

当使用 +、-、*、/、%、运算操作是，遵循如下规则：

只要两个操作数中有一个是double类型的，另一个将会被转换成double类型，并且结果也是double类型，如果两个操作数中有一个是float类型的，另一个将会被转换为float类型，并且结果也是float类型，如果两个操作数中有一个是long类型的，另一个将会被转换成long类型，并且结果也是long类型，否则（操作数为：byte、short、int 、char），两个数都会被转换成int类型，并且结果也是int类型。

但是，final类型的数据不会被转型

 

线程同步：喂，SHE

喂（Vector）

S（Stack）

H（hashtable）

E（enumeration）

 

初始化过程： 

1. 初始化父类中的静态成员变量和静态代码块 ； 

2. 初始化子类中的静态成员变量和静态代码块 ； 

3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；

4.初始化子类的普通成员变量和代码块，再执行子类的构造方法；

 

1. 父类静态变量
2. 父类静态代码块
3. 子类静态变量
4. 子类静态代码块
5. 父类非静态变量
6. 父类非静态代码块
7. 父类构造器
8. 子类非静态变量
9. 子类非静态代码块
10. 子类构造器

public class Test
{
    public static Test t1 = new Test();
    {
         System.out.println("blockA");
    }
    static
    {
        System.out.println("blockB");
    }
    public static void main(String[] args)
    {
        Test t2 = new Test();
    }
 }

静态块：用static申明，JVM加载类时执行，仅执行一次 
构造块：类中直接用{}定义，每一次创建对象时执行 
执行顺序优先级：静态块>main()>构造块>构造方法 

静态块按照申明顺序执行，先执行Test t1 = new Test();
所有先输出blockA，然后执行静态块，输出blockB，最后执行main
方法中的Test t2 = new Test();输出blockA。

sleep和wait的区别有：
  1，这两个方法来自不同的类分别是Thread和Object
  2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得敏感词线程可以使用同步控制块或者方法。
  3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
    任何地方使用
   synchronized(x){
      x.notify()
     //或者wait()
   }
   4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

使用Integer a = 1;或Integer a = Integer.valueOf(1); 在值介于-128至127直接时，作为基本类型。

使用Integer a = new Integer(1); 时，无论值是多少，都作为对象。

 

/* 1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较， 因此Integer(0)会自动拆箱为int类型再进行比较，如1,4行，显然返回true。 另外两个Integer对象进行“==”比较时，如果有一方的Integer对象是new获得的，返回false,因为比较的是两个对象的地址，如5，6。 3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true，如8,10。 4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型,若类型不同返回false, 若装箱后类型相同，则比较值，如果值相同，则返回true，否则返回false。如7,9。

** */

public class TestInteger {

    public static void main(String[] args) {
        int c = 12;
        Integer a = new Integer(12);
        Integer b = new Integer(12);
        System.out.println(a==b);
        System.out.println(a==c);
        System.out.println(a.equals(b));
    }
}

控制台输出：

false
true
true

对于String的比较，自己总结有如下规律： 1.一般来说，==比较的是引用，即地址，equal比较的是值 2.如果都是new，则比较的结果==一定是FALSE，equal则看值 3.如果先一个new，一个直接赋值一个字符串 如String a=new String（“AA”）； String b=“AA”； 此时结果==和equal都是TRUE，因为第二个在创建时会去字符串常量池找，有直接拿来用，不会专门去new 一个。 4.先直接赋值一个再new一个，则==是FALSE

https://blog.csdn.net/huanongjingchao/article/details/38443987这里讲的特别好

另外，个String功能类似的还有StringBuffer和StringBuilder,StringBuffer允许多线程操作，StringBuilder则没有，所以在效率方面String<StringBuffer<StringBuilder

方法的重写（override）两同两小一大原则：

方法名相同，参数类型相同

子类返回类型小于等于父类方法返回类型，

子类抛出异常小于等于父类方法抛出异常，

子类访问权限大于等于父类方法访问权限。

下面比较一下两者的语法区别：

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然

eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

关于String的一道笔试题

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(str1==str2);
        System.out.println(str1==str3);
        System.out.println(str3==str4);
        System.out.println(str3=="hello");
        System.out.println(str4==(str6+str7));
    }
}

上面代码的输出结果是：

false

false

true

true

false

 

String str1 = new String("hello");

这种方式创建的字符串，和正常创建对象一样，保存在堆区。

 

String str3 = "hello";

这种方式创建的字符串，保存在字符串常量区。

 

抽象类

特点:

1.抽象类中可以构造方法

2.抽象类中可以存在普通属性，方法，静态属性和方法。

3.抽象类中可以存在抽象方法。

4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。

5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。

接口

 

1.在接口中只有方法的声明，没有方法体。

2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上

public static final 

3.在接口中的方法，永远都被public来修饰。

4.接口中没有构造方法，也不能实例化接口的对象。

5.接口可以实现多继承

6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法

7.则实现类定义为抽象类。

 
二维数组的声明：
int [][] a = new int[2][2];
int [][] a = new int[2][];
int [] table [] = new int[2][2];
int [] table [] = new int[2][];

第一个就是为什么左边不用标大小，而右边需要标大小？ 
首先数组一个对象，它不属于任何类，由jvm在运行期间在堆中创建并继承object，同时添加length属性。由于数组对象所占的内存在堆上，所以在声明时应明确告诉jvm自己所占的大小，方便分配，又因为数组对象的引用在栈中，所以声明时左边就无需标大小，之所以写成2个括号，就是为了表明这个引用指向堆中的二维数组。
第二个就是为什么右边数组可以只声明几行，无需声明没行的大小？ 
大概jvm在运行期间会根据行数分配对应的可扩展空间，方便每一行进行扩充。其实又可以按c语言那样理解，行其实又是一种引用，行首地址又代表一个一维数组。

　Java中的count=count++与C++中的count=count++是不一样的

　C++中的count=count++直接等效于count++；而在Java中是这样处理的：首先将count的值（不是引用）存储在一个临时变量区，然后对count进行加1的操作，最后返回临时变量区的值。

 

举个栗子：

int count = 0;

count = count ++;

执行后 count为 0

 

c是面向过程，java和c++都是面向对象，面向对象的三大特征是：封装、继承、多态