最全Java笔试题

自己做过的总结的Java面试题，后续还会补充新的，请多多支持，一起讨论！

------------------------------------------------------------------------------------------------------------
假设 a 是一个由线程 1 和线程 2 共享的初始值为 0 的全局变量，则线程 1 和线程 2 同时执行下面的代码，最终 a 的结果不可能是（）

boolean isOdd = false;

for(int i=1;i<=2;++i)
{
if（i%2==1）isOdd = true；
else isOdd = false；
a+=i*(isOdd?1:-1)；
}

假设两线程为A、B，设有3种情况：
1.AB不并发：此时相当于两个方法顺序执行。A执行完后a=-1，B使用-1作为a的初值，B执行完后a=-2
2.AB完全并发：此时读写冲突，相当于只有一个线程对a的读写最终生效。相同于方法只执行了一次。此时a=-1
3.AB部分并发：假设A先进行第一次读写，得到a=1;之后A的读写被B覆盖了。B使用用1作为a的初值，B执行完后a=0

------------------------------------------------------------------------------------------------------------
重点：
class A { 
double f(double x, double y) { 
return x + y; 
  } 
  static int g(int n) { 
return n * n; 
} 
 } 
 class B extends A { 
double f(double x, double y) { 
double m = super.f(x, y); 
return m + x * y; 
  } 
   static int g(int n) { 
int m = A.g(n); 
     return m + n; 
   } 
 } 
 public class PrintMethod { 
public static void main(String[] args) { 
A a = new B( ); 
System.out.println(a.f(10.0,8.0)); 
    System.out.println(a.g(3)); 
  } 
 }
  
  98.0  9
  (m = 18.0  m = 18.0 + 10.0*8.0 = 98.0*8
   return 3*3
  )

 子类可以继承父类的静态方法，但是子类不能重写父类的静态方法。在这种情况下，子类隐藏了父类的静态方法。
 因为不能重写，所以a是A类型的引用时，调用的是父类中的g方法。
------------------------------------------------------------------------------------------------------------

开发与运行Java程序需要经过的三个主要步骤为
编译源程序
编译字节码
解释运行字节码

------------------------------------------------------------------------------------------------------------
关于下列程序段的输出结果
public class MyClass{
static int i;
public static void main(String argv[]){
System.out.println(i);
  }
}
0
类变量在不设置初始值时，会进行默认值赋值，而局部方法中声明的变量则必须进行初始化，它不会进行默认值赋值。
------------------------------------------------------------------------------------------------------------
Java的数据类型分为：基本数据类型和引用数据类型

一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性

接口方法默认为public，抽象类方法默认为protected

Java语言中默认整数int,默认浮点数double(而不是float);long和double都占了64位（64bit）的存储空间。

哪些情况下需要使用抽象类？
1, 当一个类的一个或多个方法是抽象方法时
2, 当类是一个抽象类的子类，并且不能为任何抽象方法提供任何实现细节或方法体时
3, 当一个类实现一个接口，并且不能为任何抽象方法提供实现细节或方法体时

------------------------------------------------------------------------------------------------------------
下列代码中第几行的sobj复合垃圾回收标准?
1,Object sobj = new Object();
2,Object sobj = null;
3,Object sobj = new Object();
4,sobj = new Object();

解析：因为第二行将sobj赋值为null，所以第一行的sobj符合标准；
      而第四行相当于把sobj赋值为null，所以第三行也符合标准。
 如果有一个对象的句柄a，且你把a作为某个构造器的参数，即
 new Constructor(a),则即使你将a赋值为null，a也不符合垃圾
 收集器的收集标准。直到由上面构造器构造的新对象被赋值为空
 时，a才可以被垃圾收集器收集。
------------------------------------------------------------------------------------------------------------
1，Object aobj = new Object();
2, Object bobj = new Object();
3, Object cobj = new Object();
4, aobj = bobj;
5, aobj = cobj;
6, cobj = null;
7, aobj = null;

解析：这种题型可能是遇到最难的题了；
      行1-3分别创建了Object的3个类对象：aobj、bobj、cobj
 行4此时对象aobj的句柄指向bobj，所以该行的执行不能使aobj符合收集标准；
 行5此时对象aobj的句柄指向cobj，所以该行的执行不能使aobj符合收集标准；
 行6：此时仍然没有任何一个对象符合收集标准；
 行7：对象cobj符合垃圾收集器的收集标准，因为cobj的句柄指向了单一的地址空间。
 在第6行的时候，cobj已经为null，但由于cobj同时指向了aobj(第五行)，cobj也不符合。
 而在第7行，aobj所指向的地址空间已经被完全赋予了空值。所以cobj符合收集标准。但
 aobj和bobj仍然判断是否符合收集标准。
总之：在Java中，判断一块内存空间是否符合垃圾收集器收集标准只有以下两个：
      (1)给对象赋予了null，以后在没有调用过；
 (2)给对象赋值了新值，即重新分配了内存空间
------------------------------------------------------------------------------------------------------------
RandomAccessFile raf = new RandomAccessFile("myfile.txt", "rw");
上面是RandomAccessFile的正确创建方式
在Java的I/O结构中， RandomAccessFile是比较不寻常的类，直接继承Object，并不属于Streams的一部分

------------------------------------------------------------------------------------------------------------
RandomAccessFile raf = new RandomAccessFile("myfile.txt", "rw");
上面是RandomAccessFile的正确创建方式
在Java的I/O结构中， RandomAccessFile是比较不寻常的类，直接继承Object，并不属于Streams的一部分
------------------------------------------------------------------------------------------------------------
下面结果会输出什么？
class Value{
public int i = 25;
}
public  class Test{
public static void main(String[] args){
Test t = new Test();
t.first();
}
public void first(){
int i = 5;
Value v = new Value();
v.i = 25;
second(v,i);
System.out.println(v.i);
}
public void second(Value v,int i){
i = 0;
v.i = 20;
Value val = new Value();
v = val;
System.out.println(v.i+" "+i);
}
}

解析：
方法参数有基本类型，如int等，另外一种是Object对象。JAVA方法
参数传对象，传的是这个对象引用的一个副本，即地址值，跟原来
的引用都是指向同一个对象。
在本题中，对象v也是传一份引用的副本，v.i=20;通过引用的副本
改变原对象的值为20。但在语句Value val = new Value();中new了一个新的
对象，然后执行v=val；相当于引用的副本指向了一本新的Object。所以，
v.i=15是改变新的Object的值，而不是改变原对象得值。
15 0 20 
------------------------------------------------------------------------------------------------------------
下面代码的输出结果是？
public static void main(String[] args) {
int num = 32;
System.out.println(num >> 32);
}
进行模32位运算，而二进制中8位是一个循环，所以num>>32相当于num>>0,
num>>33相当于num>>1，所以还是32
------------------------------------------------------------------------------------------------------------
下面代码的输出结果是？
public static void main(String[] args) {
char x = 'x';
int i = 10;
System.out.println(false ? i:x);
System.out.println(false ? 10 :x);
}
因为i是int型，第一个输出x被提升为int型了，x的int型为120，所以第一个输出120
Java编程规范中提到，当后两个表达式有一个常量表达式时(本题10)，而后一个类型为T(本题char)，
常量表达式可以被T表示时，输出结果为T类型。
所以10为常量，可以被char表示，结果输出char
------------------------------------------------------------------------------------------------------------
下面代码的输出结果是？
public class Test｛
public static void main(String[] args)｛
int a = 5;
System.out.println("value is:"+ ((a<5) ? 10.9 :9));
｝
｝
因为里面有个10.9，而后面直接跟个9，这是Java就会根据运算符的精度类型
进行自动转换，由于前面有一个10.9，后面会自动变成9.0
------------------------------------------------------------------------------------------------------------
HashCode被设计用来提高性能。equals()方法与hashCode()方法的区别在于：
1，如果两个对象相等(equal)，那么他们一定有相同的哈希值。
2，如果两个对象的哈希值相同，但他们未必相等(equal)。

设计模式：
代理模式：
定义：为其他对象提供一种代理，以控制对这个对象的访问
     代理对象起到中介的作用，可去掉功能服务或增加额外的服务
     火车票代售点就是火车站售票处的代理
常见的代理模式：
远程代理:  为不同地理的对象提供局域网代表对象，
  例：客户端&服务器
虚拟代理： 根据需要将资源消耗很大的对象进行延迟，真正需要的时候进行创建
  例：浏览帖子，正文优先加载，图片延迟加载
保护代理： 对权限进行控制
  例：只有登录才能发帖等等
   智能引用代理：  提供对目标对象额外服务
  例： 火车票代售处提供一些额外服务

以只能引用代理为例：
静态代理：代理和被代理对象在代理之前是确定的。他们都实现相同的接口或继承相同的抽象类

------------------------------------------------------------------------------------------------------------
下列哪种说法是正确的（ ）
  A 实例方法可直接调用超类的实例方法
  B 实例方法可直接调用超类的类方法
  C 实例方法可直接调用其他类的实例方法
  D 实例方法可直接调用本类的类方法

  选d，类方法就是静态方法。其它的就是实例方法
  实例方法可以对当前对象的实例变量进行操作，也可以对类变量进行操作，
  但类方法不能访问实例变量。实例方法必须由实例对象来调用，而类方法除了可由实例对象调用外，还可以由类名直接调用。
  另外，在类方法中不能使用 this 或 super。 关于类方法的使用，有如下一些限制：
  1 在类方法中不能引用对象变量。
  2 在类方法中不能使用super、this关键字。
  3 类方法不能调用类中的对象方法。与类方法相比，实例方法几乎没有什么限制：
  1 实例方法可以引用对象变量（这是显然的），也可以引用类变量。
  2 实例方法中可以使用super、this关键字。
  3 实例方法中可以调用类方法。
------------------------------------------------------------------------------------------------------------

关于C++/JAVA类中static 成员和对象成员的说法正确的是？
 A static 成员变量在对象构造时生成
 B static 成员函数在对象成员函数中无法调用
 C 虚成员函数不可能是static成员函数
 D static 成员函数不能访问static成员变量

 static为成员变量或函数，在类初始化是加载完成，可以被成员函数调用或访问
 在java语言中虚函数指代的就是抽象方法，抽象方法中不能用private，static，synchronized，native等修饰词修饰。

------------------------------------------------------------------------------------------------------------
有如下一段代码，请选择其运行结果（）
 public class StringDemo{
    private static final String MESSAGE="taobao";
    public static void main(String [] args) {
       String a ="tao"+"bao";
       String b="tao";
       String c="bao";
       System.out.println(a==MESSAGE);
       System.out.println((b+c)==MESSAGE);
    }
  }
 Java对String的相加是通过StringBuffer实现的，先构造一个StringBuffer里面存放”tao”,
 然后调用append()方法追加”bao”，然后将值为”taobao”的StringBuffer转化成String对象。
 StringBuffer对象在堆内存中，那转换成的String对象理所应当的也是在堆内存中。
 MESSAGE成员变量及其指向的字符串常量肯定都是在栈内存里的
 对于字符串常量的相加，在编译时直接将字符串合并，而不是等到运行时再合并。也就是说
 String a = "tao" + "bao" 和String a =  "taobao"编译出的字节码是一样的。
 所以等到运行时，根据上面说的栈内存是数据共享原则，a和MESSAGE指向的是同一个字符串。

------------------------------------------------------------------------------------------------------------
接口和抽象类：
相同点：都不能被实例化,位于继承树的顶端，都包含抽象方法
不同点：1、设计目的：
接口：
     体现的一种规范，类似与整个系统的总纲，
               制订了系统各模块应该遵循的标准，因此接口不应该经常改变，一旦改变对整个系统是辐射性的。
抽象类：
                      作为多个子类的共同父类，体现的是一种模板式设计，可以当作系统实现过程中的中间产品，已经实现了系统部分功能。
        2、使用不同
    （1）接口只能包含抽象方法，抽象类可以包含普通方法。
    （2）接口里不能定义静态方法，抽象类可以。
    （3）接口只能定义静态常量属性，不能定义普通属性，抽象类可以。
    （4）接口不包含构造器，抽象类可以（不是用于创建对象而是让子类完成初始化）。
    （5）接口里不能包含初始化块，抽象类完全可以。
    （6）接口多继承，抽象类单继承（只能有一个直接父类）。
总结：
   接口所有方法全是抽象方法只能public abstract修饰（默认public abstract修饰）,属性默认public static final修饰。
抽象类除了包含抽象方法外与普通类无区别。 

------------------------------------------------------------------------------------------------------------

关于volatile关键字，下列描述
A 用volatile修饰的变量，每次更新对其他线程都是立即可见的   //正确
B 对volatile变量的操作是原子性的   //错误
C 对volatile变量的操作不会造成阻塞   //正确
D 不依赖其他锁机制，多线程环境下的计数器可用volatile实现     //错误


------------------------------------------------------------------------------------------------------------
两个最基本的java回收算法：
   复制算法和标记清理算法
                复制算法：两个区域A和B，初始对象在A，继续存活的对象被转移到B。此为新生代最常用的算法
                标记清理：一块区域，标记要回收的对象，然后回收，一定会出现碎片，那么引出
                标记-整理算法：多了碎片整理，整理出更大的内存放更大的对象
   两个概念：新生代和年老代
                新生代：初始对象，生命周期短的
                永久代：长时间存在的对象
   整个java的垃圾回收是新生代和年老代的协作，这种叫做分代回收。
   P.S： Serial New收集器是针对新生代的收集器，采用的是复制算法
         Parallel New（并行）收集器，新生代采用复制算法，老年代采用标记整理
         Parallel  Scavenge（并行）收集器，针对新生代，采用复制收集算法
         Serial Old（串行）收集器，新生代采用复制，老年代采用标记清理
         Parallel   Old（并行）收集器，针对老年代，标记整理
         CMS收集器，基于标记清理
         G1收集器：整体上是基于标记清理，局部采用复制


综上：新生代基本采用复制算法，老年代采用标记整理算法。cms采用标记清理。

------------------------------------------------------------------------------------------------------------
Java虚拟机功能：
 1 通过 ClassLoader 寻找和装载 class 文件
 2 解释字节码成为指令并执行，提供 class 文件的运行环境
 3 进行运行期间垃圾回收
 4 提供与硬件交互的平台

------------------------------------------------------------------------------------------------------------
关于ThreadLocal以下说法正确的是？
A ThreadLocal继承自Thread         //错误，ThreadLocal继承Object，相当于没继承任何特殊的。
B ThreadLocal实现了Runnable接口         //错误，ThreadLocal没有实现任何接口
C ThreadLocal重要作用在于多线程间的数据共享       //错误
D ThreadLocal是采用哈希表的方式来为每个线程都提供一个变量的副本              //正确
E ThreadLocal保证各个线程间数据安全，每个线程的数据不会被另外线程访问和破坏   //正确


   线程的角度看，每个线程都保持一个对其线程局部变量副本的隐式引用，只要线程是活动的并且 ThreadLocal 实例是可访问的；
在线程消失之后，其线程局部实例的所有副本都会被垃圾回收

------------------------------------------------------------------------------------------------------------
以下JAVA程序的输出是什么（）
public class HelloSogou{
     public static synchronized void main(String[] a){
         Thread t=new Thread(){
             public void run(){Sogou();}
     };
     t.run();
     System.out.print("Hello");
     }
     static synchronized void Sogou(){
     System.out.print("Sogou");
    }
}
A HelloSogou     B SogouHello        C Hello       D 结果不确定
------------------------------------------------------------------------------------------------------------

如果是t.start()，(静态同步函数的锁是该类的字节码文件.class main函数和Sogou方法都是static的，所以持有相同锁
HelloSogou.class那么，在main线程（main 是一个线程也是一个进程 ）中又开了一个线程，调用Sogou方法，锁会冲突。 选D
但是，t.run()只是普通方法，顺序执行，选B

------------------------------------------------------------------------------------------------------------
ServerSocket (int port)
创建一个serversocket 绑定在特定的端口

Socket(InetAddress address, int port)
创建一个socket流，连接到特定的端口和ip地址

------------------------------------------------------------------------------------------------------------

一般关系数据模型和对象数据模型之间有以下对应关系：表对应类，记录对应对象，表的字段对应类的属性。

------------------------------------------------------------------------------------------------------------
线程通过调用对象的synchronized方法可获得对象的互斥锁定；
线程调度算法是平台独立的：
线程调度分为协同式调度和抢占式调度，Java使用的是抢占式调度，也就是每个线程将由操作系统来分配执行时间，
线程的切换不由线程本身来决定（协同式调度）。这就是平台独立的原因。

------------------------------------------------------------------------------------------------------------
优化Hibernate所鼓励的7大措施：
1.尽量使用many-to-one，避免使用单项one-to-many
2.灵活使用单向one-to-many
3.不用一对一，使用多对一代替一对一
4.配置对象缓存，不使用集合缓存
5.一对多使用Bag 多对一使用Set
6.继承使用显示多态 HQL:from object polymorphism="exlicit" 避免查处所有对象
7.消除大表，使用二级缓存
------------------------------------------------------------------------------------------------------------
class Car extends Vehicle
{
    public static void main (String[] args)
    {
        new  Car(). run();
    }
    private final void run()
    {
        System. out. println ("Car");
    }
}
class Vehicle
{
    private final void run()
    {
        System. out. println("Vehicle");
    }
}
首先final声明的方法是不能被覆盖的，但是这里并不错误，因为方法是private的，
也就是子类没有继承父类的run方法，因此子类的run方法跟父类的run方法无关，并不是覆盖。
new Car().run()也是调用子类的run方法。输出Car。
************************************************************************************************************v
************************************************************************************************************
public class Test2
{
    public void add(Byte b){
        b = b++;
    }
    public void test(){
        Byte a = 127;
        Byte b = 127;
        add(++a);
        System.out.print(a + " ");
        add(b);
        System.out.print(b + "");
    }
}
public void add(Byte b){ b=b++; } 这里涉及java的自动装包/自动拆包(AutoBoxing/UnBoxing) 
Byte的首字母为大写，是类，看似是引用传递，但是在add函数内实现++操作，会自动拆包成byte值传递类型，
所以add函数还是不能实现自增功能。也就是说add函数只是个摆设，没有任何作用。 Byte类型值大小为-128~127之间。
add(++a);这里++a会越界，a的值变为-128 add(b); 前面说了，add不起任何作用，b还是127

************************************************************************************************************
************************************************************************************************************

class C {
    C() {
        System.out.print("C");
    }
}
class A {
    C c = new C();
 
    A() {
        this("A");
        System.out.print("A");
    }
 
    A(String s){
        System.out.print(s);
    }
}
class Test extends A{
    Test(){
        super("B");
        System.out.print("B");
    }
 
    public static void main(String[] args) {
        new Test();
    }
}
//解答1：
初始化过程是这样的： 父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数
1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化； 
2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化； 
3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法；
4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法； 
 
（1）初始化父类的普通成员变量和代码块，执行 C c = new C(); 输出C 
（2）super("B"); 表示调用父类的构造方法，不调用父类的无参构造函数，输出B 
（3） System.out.print("B"); 
 所以输出CBB
//解答2：
首先new了一个子类对象，那么就要调用构造方法来初始化该子类对象，但是该类继承自A，所以要先调用父类的构造方法，
这里通过super("B")显示的调用了父类的带参构造。
执行父类的带参构造前要先对父类中的对象进行初始化，对父类中的c成员进行初始化，调用了C类的无参构造，所以调用顺序为：
先调用C类的无参构造
再调用A类的带参构造
最后调用调用子类的构造

------------------------------------------------------------------------------------------------------------

假设有以下代码String s = "hello"：String t = “hello”；char c [ ] = {'h','e','l','l','o'}；下列选项中返回false的语句是？
A s.equals (t)；
B t.equals (c)；
C s==t；
D t.equals (new String ("hello"))；


Sting 类保存字符串只是保存所有单单的字符串;
而 char[] 字符数组 会在最后自动加上'\n';
所以B:t.equals(c)会返回fasle；
所以 答案B

------------------------------------------------------------------------------------------------------------

根据下面的代码，
String s = null;
会抛出NullPointerException异常的有:
  A if( (s!=null) & (s.length()>0) )  B if( (s!=null) && (s.length()>0) )
  C if( (s==null) | (s.length()==0))  D if( (s==null) || (s.length()==0) )

String s=null;没有给s开辟任何空间，当执行length()方法时候，
因为没有具体指向的内存空间，所以报出NullPointerException没有指向的错误。
A &是与，位运算，两个都得执行，执行到s.length()自然就报错了。
B s！=null  结果为false 整体就为false ，&& 后面就不会执行。下面的同理。 AC

************************************************************************************************************
************************************************************************************************************
HashMap和Hashtable两个类都实现了Map接口，二者保存K-V对（key-value对）
HashTable不允许null值(key和value都不可以),HashMap允许null值(key和value都可以)。
Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步
迭代 HashMap 采用快速失败机制，而 HashTable 不是，因为 HashTable是线程安全的
HashMap把Hashtable的contains方法去掉了,改成 containsvalue 和 containsKey。因为contains方法容易让人引起误解
HashTable使用Enumeration，HashMap使用Iterator

************************************************************************************************************
************************************************************************************************************
例化线程： 1、如果是扩展java.lang.Thread类的线程，则直接new即可。
           2、如果是实现了java.lang.Runnable接口的类，则用Thread的构造方法：


public class MyRunnable implements Runnable{ 
     public void run()             { 
        (new Thread(new MyRunnable()).start()
     } 
 }

------------------------------------------------------------------------------------------------------------

<<表示左移位
>>表示带符号右移位
>>>表示无符号右移
但是没有<<<运算符
-----------------------------------------------------------------------------------------------------------
  CopyOnWriteArrayList适用于读多写少的并发场景
  ReadWriteLock即为读写锁，要求写与写之间互斥，读与写之间互斥，读与读之间可以并发执行。在读多写少的情况下可以提高效率
  ConcurrentHashMap是同步的HashMap，读写都加锁
  volatile只保证多线程操作的可见性，不保证原子性

------------------------------------------------------------------------------------------------------------
String str = new String("abc")，"abc"在内存中是怎么分配的？
A 堆
B 栈
C 字符串常量区
D 寄存器
当你new String("abc")时，其实会先在字符串常量区生成一个abc的对象，然后new String()时会在堆中分配空间，然后此时会把字符串常量区中abc复制一个给堆中的String，故abc应该在堆中和字符串常量
------------------------------------------------------------------------------------------------------------
byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2);  /*语句1*/
b6=b4+b5;    /*语句2*/
b8=(b1+b4);  /*语句3*/
b7=(b2+b5);  /*语句4*/
上面代码片段中，存在编辑错误的语句是?
本题答案应为：B、C、D

Java表达式转型规则由低到高转换：
1、所有的byte,short,char型的值将被提升为int型；
2、如果有一个操作数是long型，计算结果是long型；
3、如果有一个操作数是float型，计算结果是float型；
4、如果有一个操作数是double型，计算结果是double型；
5、被fianl修饰的变量不会自动改变类型，当2个final修饰相操作时，结果会根据左边变量的类型而转化。

语句1错误：b3=(b1+b2);  自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；
语句2正确：b6=b4+b5;    b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；
语句3错误：b8=(b1+b4);  虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);
语句4错误：b7=(b2+b5);  同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变。
------------------------------------------------------------------------------------------------------------

Java类Demo中存在方法func0、func1、func2、func3和func4，请问该方法中，哪些是不合法的定义？( )
public class Demo{
　　float func0() byte,short,char-> int -> long -> float -> double
　　{ 小转大不用强转，大转小需要强转
　　　　byte i=1; func1  没有返回值；func4  大转小需要强转
　　　　return i;
　　}
　　float func1()
　　{
　　　　int i=1;
　　　　return;
　　}
　　float func2()
　　{
　　　　short i=2;
　　　　return i;
　　}
　　float func3()
　　{
　　　　long i=3;
　　　　return i;
　　}
　　float func4()
　　{
　　　　double i=4;
　　　　return i;
　　}
}
------------------------------------------------------------------------------------------------------------


java中除了基本数据类型都是引用数据类型
java中的基本数据类型如下：
byte   short  int   long   float   double   char  boolean
除此之外都是引用类型

------------------------------------------------------------------------------------------------------------
可用来实现线程间通知和唤醒：
    Object.wait/notify/notifyAll
    Condition.await/signal/signalAll

------------------------------------------------------------------------------------------------------------

Statement是sql语句的载体
Statement是标准的Statement类，通过字符串对sql语句进行拼接，但是它存在sql注入的危险
PreparedStatement对sql语句进行了预编译，可以防止SQL注入
CallableStatement用来调用存储过程的
BatchedStatement用于批量操作数据库，BatchedStatement不是标准的Statement类

------------------------------------------------------------------------------------------------------------
面向对象的五大基本原则：
   单一职责原则（SRP）
   开放封闭原则（OCP） 
   里氏替换原则（LSP） 
   依赖倒置原则（DIP） 
   接口隔离原则（ISP）
------------------------------------------------------------------------------------------------------------
下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是？
A 实例变量指的是类中定义的变量，即成员变量，如果没有初始化，会有默认值    // 正确
B 局部变量指的是在方法中定义的变量，如果没有初始化，会有默认值            //********局部变量必须有初始值******
C 类变量指的是用static修饰的属性       //正确
D final变量指的是用final修饰的变量       //正确
------------------------------------------------------------------------------------------------------------
构造函数不可以用private修饰   //错误，单例模式中，构造器私有化
构造函数必须与类名相同        //正确
构造方法不能被子类继承，所以用final修饰没有意义。
构造方法用于创建一个新的对象，不能作为类的静态方法，所以用static修饰没有意义。
此外，Java语言不支持native或synchronized的构造方法
------------------------------------------------------------------------------------------------------------
Java默认使用Unioncode编码，即不论什么语言都是一个字符占两个字节
Java的class文件编码为UTF-8，而虚拟机JVM编码为UTF-16
UTF-8编码下，一个中文占3个字节，一个英文占1个字节
Java中的char默认采用Unicode编码，所以Java中char占2个字节
1(byte)字节=8(bit)位
------------------------------------------------------------------------------------------------------------

floor:   求小于参数的最大整数。返回double类型-----n. 地板，地面
         例如：Math.floor(-4.2) = -5.0
ceil:   求大于参数的最小整数。返回double类型-----vt. 装天花板；
         例如：Math.ceil(5.6) = 6.0
round:  对小数进行四舍五入后的结果。返回int类型
         例如：Math.round(-4.6) = -5

------------------------------------------------------------------------------------------------------------
Integer i = 42;
Long l = 42l;
Double d = 42.0;   下面为true的是?


A i == l         B i == d      C l == d
D i.equals(d)        E d.equals(l)        F i.equals(l)      G l.equals(42L)

ABC3 个选项很明显，不同类型引用的 == 比较，会出现编译错误，不能比较。
DEF 调用 equals 方法，因为此方法先是比较类型，而 i ， d ， l 是不同的类型，所以返回假。
选项 G ，会自动装箱，将 42L 装箱成 Long 类型，所以调用 equals 方法时，类型相同，且值也相同，因此返回真

------------------------------------------------------------------------------------------------------------

Java致力于检查程序在编译和运行时的错误
Java虚拟机实现了跨平台接口
类型检查帮助检查出许多开发早期出现的错误
Java自己操纵内存减少了内存出错的可能性
Java还实现了真数组，避免了覆盖数据的可能
注意，是避免数据覆盖的可能，而不是数据覆盖类型 

------------------------------------------------------------------------------------------------------------

java不允许单独的方法，过程或函数存在,需要隶属于某一类中
java语言中的方法属于对象的成员,而不是类的成员。不过，其中静态方法属于类的成员

------------------------------------------------------------------------------------------------------------

形式参数可被视为local variable
对于形式参数只能用final修饰符
形参的值在调用时根据调用者更改，实参则用自身的值更改形参的值（指针、引用皆在此列），也就是说真正被传递的是实参