java基础(1-50)-------->超级简单，不信你不会！！！

1:java中的保留字:const&goto;

2:&和&&都可以做逻辑运算符，即运算符两边的表达式都为true,结果才为true,一方为false,则结果为false;

不同的是：&&具有短路的功能，举个例子：

对于if(str != null && !str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException;

如果将&&改为&，则会抛出NullPointerException异常。

3:在switch(expression)中可以是：byte,short,int,char,enum,String(JDK1.7以上)；

原因：expression只能是一个整数表达式或者枚举常量，整数表达式可以是int类型或Integer包装类型。由于，byte，short，char都可以隐式转换为int类型，所以，这些类型也可以用作表达式。

另外jdk7以后，switch表达式也可以为String类型；

注：这个新特性是在编译器这个层次上实现的。而在 Java 虚拟机和字节代码这个层次上，还是只支持在 switch 语句中使用与整数类型兼容的类型。;

4:

批注：

　　隐士转换（自动类型转换）：

　　特征：从小到大，从存储范围小的类型到存储范围大的类型，数据类型将自动提升。

　　byte,short.char-->int-->long-->float-->double

　　记：long的范围小于float的。　

　　显示类型转换（强制类型转换）。

　　特征：从大到小，从存储范围大的类型到存储范围小的类型。

　　double-->float-->long-->int-->short-->byte；

　　一般情况不推荐使用强制类型转换，会造成精度的丢失;

　　例：

short  s1=1;s1=s1+1;

由于s1+1运算时会自动提升表达式的类型(隐士转换)，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。

short s1=1;s1+=1;

由于 += 是java语言规定的运算符，java编译器会对它进行特殊处理，s+=1中有一个强制转换，即s=(short)(s+1),会把s+1的值强制转换为short类型，故不会报错。

5: java八大基本数据类型所占的字节数（1字节=8位）以及取值范围：

byte=1字节（ -128到127之间）;     short=2字节 （ -32768~32767）;   int=4 字节（-2^31到2^31-1之间）;    long=8字节（ -2^63到2^63-1之间）;

float=4字节（1.4E-45~3.4E+38，-1.4E-45~-3.4E+38）;       double=8字节（4.9E-324~1.7E+308,-4.9E-324~-1.7E+308）;                                     char=2;  boolean=1;

注：1个英文字符=1个字节，  1个汉字=2个字节，   String相当于char类型的数组，有多少字符就有多少字节。因为java中的char是两个字节的，所有可以用来存储中文(一个中文也是两个字节)，而在c语言中char只是一个字节，所有不能用来存储中文，要想存储中文，只能用字节数组。

6：位运算符

注：01：位运算符对操作数以二进制位单位进行运算；02：位运算的操作数是整数，即：int,short,long,byte和char;即位运算的结果也是整数类型;

　　03:如果操作数是char、byte、short,在位运算前其值会自动晋升为int,运算结果也是int;

运算符：

&：两个操作数都是1，结果才是1；    |：两个操作数一个是1，结果是1；

~（取反）：操作数为1，结果为0，反之；     <<(左移):右边空位补0；    >>(右移):左边空位补最高位即符号位；

>>>（无符号右移）：左边空位补0;

例：计算5&6；   5：00000101/00000110：6==00000100=4；

　　计算6<<2:6左移2位相当于扩大4倍即：24；

　　计算12>>3:12右移2位相当于缩小8倍即：1；

例：最有效率的方法算出2*8=？；即2<<3,左移n位，相当于乘以2的n次方,  因为位运算cpu直接支持，效率最高。

7：对象引用变量，对象本身；

Student stu=new Student()；

01：new Student()以Student类为模板在堆中创建一个类对象；

02：立即调用Student类的构造方法对刚生成的对象初始化；

03:创建stu的引用变量用来指向Student对象的对象引用，

04:=操作符使对象的引用指向刚创建的对象；

注：一个引用可以指向多个对象，一个对象可以被多个引用指向；

Student stu;

stu=new Student("张三"); stu=new Student("李四")；

Student  stu=new Student("张三");

Student stu1=stu;

例：使用final关键字修饰一个变量，是引用变量（对象引用）不能改变，还是这个引用的对象（对象）不能改变；

final StringBuffer  a=new StringBuffer("张三");

01：a=new StringBuffer("李四")；一个引用变量可以指向多个对象，但是此行编译报错，因此引用被重新赋值，即final关键字修饰一个变量，是引用变量不能改变。

02：引用变量所指向的对象中的内容是可以改变的；如：a.append("小白")；

8:"=="和equals的区别？？？

基本数据类型：byte,short,int,long,float,long,char,boolean,它们之间的比较用==，比较的是值相等；

引用数据类型：当它们用==比较的时候，比较的是内存地址，准确一点是堆的内存地址。（

String a1 = new String("张三");
String b1 = new String("张三");
System.out.println(a1 == b1);====>flase;

）

equals()方法：

在object类中定义了一个equals的方法，初始行为是比较对象的内存地址（源码得知），但在一些类库中这个方法被重写了，如String,Interger,Date。在这些类中有其自身的实现，不在比较类在堆内存中存放地址了.像String重写equals()即比较两个字符串的内容是否相等。

分开来看即可。

9：静态变量和实例变量的区别？

语法定义上：静态变量前要加static关键字，而实例变量不需要。

程序运行时的区别：实例变量属于某个对象属性，必须创建实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量；

静态变量即类变量，可以通过类名之间调用，只要程序加载了类的字节码文件，静态变量就会被分配空间。即可使用。实例变量则通过创建后的对象来调用。

总之：类变量是所有对象共有的，实例变量则属对象私有。

10：从一个静态方法内部对非static方法进行调用：显然是不可以的啦，普通方法必须由创建对象后在对象上来调用，静态方法调用不用创建任何对象，存在的问题是静态方法调用可能还没有创建任何实例对象，那这个普通方法关联到哪个对象上面呢。显然是不成立的。

11：int和integer的区别

首先integer是int提供的封装类；

1：int的默认值是0，而integer的默认值是null;即integer可以区分未赋值和值为0的区别；int无法表达未赋值的情况。

2：jsp开发中integer默认是null,EL表达式在文本框中显示是空白字符串，而int的默认是，所以用el表达式在文本框中显示时，结果是；即int不适合作为web层的表单数据类型。

3：在Hibernater中，如果将OID定义为Interger类型，那么Hibernate就根据其值是否为null而判断一个对象是否是临时的，如果将OID定义为int类型，还需要在hbm映射文件中设置其unsaved-value属性为0.

12：Math.round(11.5)和Math.round(-11.5);

Math类中常见三个方法：ceil(天花板）：向上取整;Math.ceil(11.2)=12;

floor(地板)：向下取整     Math.floor(-11.6)=-12;

round:四舍五入    算法：将括号内的数+0.5之后，向下取值。

即：round(3.4)===>3.4+0.5=3.9,向下取值是3；round（-11.5)====>-11.5+0.5=-11,向下取值：-11；

13：public  default  protected  private 的访问作用域区别：

private：私有的只可以在本类或者内部类中访问。

default:只能在同一个包中访问。

protected:可以在同一个包内和子孙类中访问。

public:全局访问。

14：方法重载（overload）和方法重写（override）的区别：

重写关系：父子类       方法同名，同参，返回值相同或者是其子类，访问权限不能严于父类。

注：子类重写方法不能抛出比父类更多的异常，不能重写被标识final和private的方法，一个方法不能被继承就不能重写。

重载关系：同一个类    方法同名，参数列表不同（个数，类型，顺序），和返回值访问权限无关。

15：has a与is a的区别;

is-a的关系是属于，  应使用继承;菱形、圆形和方形都是形状的一种。

has-a的关系是包含，应该使用聚合;比如锁包含上锁和开锁的功能。

is-like-a的关系：应该使用组合;比如空调继承制冷机同时实现加热的接口。

16：java堆（heap）和栈(stack)的区别；有一个64k的字符串放到堆上还是放到栈上？
01：存放的对象不同：
在函数中定义的一些基本类型的变量和对象的引用变量都在栈内存中分配。（基本数据类型的全局变量存放在java堆中的，因为它不是静态的变量，不会独立于类的实例而存在）；
堆内存用来存放由new创建的对象和数组。
02：性能上的不同。
栈空间小，存取速度比堆要快，仅次于直接位于CPU中的寄存器；
缺点是存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。
堆空间大，优势是可以动态的分配内存大小，生存期也不必事先告诉编译器，java的垃圾收集器会自动收走这些不再使用的数据，由于要在运行时动态分配内存，存取速度较慢。
由于堆的速度慢容量大，栈的速度快容量小，一个64k的字符串，自然放在堆中。

总结：
成员变量有静态和非静态的，静态成员变量是共享数据存放在方法区中。
非静态成员变量在堆内存中作用于整个类。
局部变量基础类型存放在栈内存中，引用类型，引用存放在栈上，引用指向的对象在堆上。

17：JDK,JRE,JVM三者的区别:
JDK：java开发工具包，JDK是整个java的核心：包括JRE，一堆java工具和java基础类库。

JRE:java运行环境，所有的java程序都要在jre环境下才能运行，包含了jvm,java的核心类库！但不包含开发工具---编译器，调试器。

JVM：java虚拟机，属于jre的一部分；主要工作：解释自己的字节码文件，并且映射到本地的cpu指令继续的OS系统调用。java是跨平台的，就是基于jvm的。

补充：
java类库概念：java的应用程序的接口（API）以包的形式来组织，每个包提供大量的相关类、接口和异常处理类，这些包的集合就是java的类库。

包名以java开始的包是java核心包；
包名以javax开始的包是java扩展包；
常用的java核心包

1：java.lang java编程语言的基本类库;（objec类，math类，线程类，字符串类，错误和异常处理类）
2:java.NET 用于实现网络通讯应用的所有类。
3：java.util 集合类、日期时间工具等常用工具包。（日期：Date,calendar,随机数类：Random,散列表类：Hashtable）
4：java.io 通过数据流、对象序列以及文件系统实现的输入输出。
5：java.sql 访问和处理来自java标准数据源数据的类。

18:接口和抽象类的区别，以及什么时候使用？

当需求明确某些功能的实现方法时，彼此之间有些共性的东西，可用抽象；

即：如果一个抽象类中加入一个新的具体方法时，那么它所有的子类都能得到这个新方法，而java接口加入一个新的方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每个类都再实现这个方法才行，这显然是java 接口的缺点。

当需求要完成一个功能的时候，两个事物联系不大，可以用接口。
门：开关的方法可以定义到抽象类中，门的种类很多，都有开关的功能；is - a
报警器跟门一般关系不大，可以用接口，有的门就没有报警器功能,只要实现这个接口便能拥有这个功能。has - a

这种选择还得具体问题具体分析。

接口和抽象类的区别：
相同点：都可以被继承，都不能被实例化，派生类必须实现未实现的方法。

不同点：
1：抽象类可以有构造方法，接口没有。（实例化）
2：接口中只能存在抽象的方法，但是抽象类可以有普通方法。（方法）
3：接口中的成员变量都是静态常量 public static final修饰的；抽象类中的成员变量没有特殊的要求。（变量）
4：一个类只能继承一个抽象类，但是实现多个接口。（实现）

19：有一个100万的数组，里面有两个是重复的，如何设计算法找到。

public static void main(String[] args) {
int a[] = { 6, 4, 18, 10, 24, 8, 9, 16, 19, 13, 25, 15, 12, 11, 2, 0,
14, 17, 12, 5 };
int n = a.length;
Set<Integer> set = new HashSet<Integer>();
for (int i = 0; i < n; i++) {
if (!set.add(a[i])) {
System.out.println(a[i]);
break;
}
}
}

20：javaSE和javaEE,javaME的区别
java有三种平台，SE,EE,ME,他们可以调用共同的类库;
javaSE:标准版，包含了java核心类库，主要用来开发桌面应用。
javaEE:企业版，包含SE,又有扩展部分（servlet,JDBC等），主要用来开发网站。
javaME：微型版，包含SE的部分类库，又有自己扩展部分，主要用来做移动类，嵌入式开发。

21：java常用的设计模式，再针对你熟悉的模式谈谈你的理解。
注：使用设计模式为了让代码重用，让代码更容易被他人理解，保证代码可靠性。
总共23种，设计模式可以分为创建型，结构型和行为型。

创建模式用来处理创建对象的创建过程，主要包含以下5种：
原型模式，单例模式，工厂方法模式，抽象工厂模式，建造者模式。

结构型模式用来处理类或者对象的组合，主要包含以下7种：
适配器模式，桥接模式，组合模式，装饰者模式，外观模式，享元模式，代理模式。

行为型模式用来对类或者对象怎样交互和怎样分配职责进行描述，主要包含以下11种：
责任链模式，命令模式，解释器模式，迭代器模式，中介者模式，备忘录模式，观察者模式，状态模式，策略模式，模板方法模式，访问者模式。

单例模式：单例对象能保证在一个jvm中，该对象只有一个实例存在，对于某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销，省去new操作符，降低系统内存的使用频率，减轻GC压力。

补充：
设计模式的六大原则
1：开闭模式：对扩展开发，对修改关闭;在程序需要扩展的时候不去修改原代码。
2：里氏代换原则：任何基类可以出现的地方，子类一定可以出现。
3：依赖倒转原则：针对接口编程，依赖抽象而不是依赖具体。
4：接口隔离原则：使用多个隔离的接口，比使用单个接口要好，降低类之间的耦合度。
5：迪米特法则（最少知道原则）：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块独立。
6：合成复用原则：尽量使用合成/聚合的方式，而不是使用继承。

22：Struts的工作流程
01：客户端发起一个HttpServletRequest的请求，这个请求经过一系列的过滤器（Filter）,接着FiterDispatcher被调用.
02：FiterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action.如果决定需要调用某个Action,FilterDispatcher把请求的处理交给ActionProxy。
03：ActionProxy通过Configuration Manager(struts.xml)询问框架的配置文件，找到需要的Action类。Acctionproxy创建一个ActionInvocation实例
04：同时ActionInvocation通过代理模式调用Action,但在调用之前，ActionInvocation会根据配置加载Action相关的所有interceptor(拦截器)。
05：一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果result.
06:最后通过HttpServletResponse返回客户端一个相应。