基础类型和语法

1.变量及其作用范围？

解析：应该从三方面进行解释：变量的定义，Java变量的类别和含义，变量的作用范围
答:
1 变量是指在程序运行过程中随时可以发生变化的量，是数据的临时存放场所
2在Java中，变量根据生成周期可以分为静态变量，成员变量和局部变量三种。

• 静态变量是指在类中用static修饰的变量
• 成员变量是类中没有用static修饰的变量，它属于该类的某个实例也就是对象，随着对象的加载而出事话，随着对象被垃圾回收而小时。
• 局部变量是定义带方法或者代码块中的变量或者方法的参数，随着方法的调用而创建，随着方法的执行完毕而消失。它的作用范围有又大括号来界定。

---

2.java的变量分为那两种大的数据类型？

基本类型和引用类型

数据类型示意图

两者区别从数值存储方面来说：基本数据类型存储的直接是数据的值，二引用类型存放的是数据所存在的地址。
从内存方面来说：基本数据类型和引用类型的区别主要在于基本数据类型是分配在栈上的，而引用类型是分配在堆上的。

---

相关：
定以两个String对象

String a = new String("abc");
String b = new String("abc");
然后
if(a==b){
System.out.println("a==b");
}
else{
System.out.println("a!=b");
}

程序输出a!=b原因:a和b的地址是不相同的，a==b比较的是两个变量的地址
定义两个基本类型

int a=4;int b=4;
if(a==b)
{
System.out.println("a==b");
}else{
System.out.println("a!=b");
}

输出：a==b原因：==比较的是两个变量的内容

1. 基本类型的创建
   当你在函数中创建一个基本类型的变量时，比如如下语句：
   int n = 123;
   这个变量n的值也是存储在栈（Stack）上的，但是这个语句不需要再从堆中申请内存了。

2. 引用类型的创建
   当你在函数中创建一个引用类型的对象
   例如，有一个类Person,有属性name,age,带有参的构造方法，
   Person p = new Person("Tom",20);
   在内存中的具体创建过程是：
   1.首先在栈内存中位其p分配一块空间;(保存对象地址)
   2.在堆内存中为Person对象分配一块空间，并为其三个属性设初值""，0；
   3.根据类Person中对属性的定义，为该对象的两个属性进行赋值操作；
   4.调用构造方法，为两个属性赋值为"Tom",20；（注意这个时候p与Person对象之间还没有建立联系）；
   5.将Person对象在堆内存中的地址，赋值给栈中的p;通过句柄p可以找到堆中对象的具体信息。

---

3.Java包含那些基本数据类型及其包装类

当有的地方必须要使用对象或者引用数据类型时候，例如集合类（LIst、set等），基本数据类型就不能使用了，因为他们的存储原理和引用数据类型完全不一样。

可以把基本数据类型转换成包装类：

int i=10;                      //定义int变量
Intaher itg=Intager.valueOf(i);//用valueOf（）方法把i转变成Intager变量
Itg=new Intager(i)             //用构造方法创建
List list=new ArrayList（）；
list.add(itg);

注意：从Java5开始有自动装箱和拆箱的功能不用显示进行转换。

---

4.如何理解Java中的自动装箱和拆箱

基本数据类型的自动装箱和拆箱是Java5.0提供的新功能
Java中的自动装箱与拆箱指的是基本数据类型与其包装类型的相互转换。

装箱
直接将一个基础数据类型传给其相应的封装类(wrapper class)的做法，便是自动装箱(Autoboxing)。

以整型为例：
Integer i=100;
从上面的代码中，大家可以得知，i为一个Integer类型的引用，100为Java中的基础数据类型(primitive data type)。

原理：装箱就是jdk自己帮你完成了调用Integer.valueOf(100)
源码：

    public static Integer valueOf(int i) {  
        if(i >= -128 && i <= IntegerCache.high)  
            return IntegerCache.cache[i + 128];  
        else  
            return new Integer(i);  
    }  

拆箱

拆箱与装箱是相反的操作。装箱是将一个原始数据类型赋值给相应封装类的变量。而拆箱则是将一个封装类的变量赋值给相应原始数据类型的变量。装箱、拆箱的名字也取得相当贴切。

原理：

jdk帮我们完成了对intValue()方法的调用。
源码：

 public int intValue() {  
    return value;  
    }  

Integer integer100=100;  
int int100=integer100;  

例题：
在jdk1.5的环境下，有如下4条语句,输出结果为false的是：

Integer i01 = 59;
int i02 = 59;
Integer i03 =Integer.valueOf(59);
Integer i04 = new Integer(59)。

A. System.out.println(i01== i02);
B. System.out.println(i01== i03);
C. System.out.println(i03== i04);
D. System.out.println(i02== i04);

正确答案: C

解析一：

JVM中一个字节以下（-127（11111111）到+127（01111111））的整型数据会在JVM启动的时候加载进内存，除非用new Integer()显式的创建对象，否则都是同一个对象
所有只有i04是一个新对象，其他都是同一个对象。所有A，B选项为true
C选项i03和i04是两个不同的对象，返回false
D选项i02是基本数据类型，比较的时候比较的是数值，返回true

解析二：

Integer i01=59 的时候，会调用 Integer 的 valueOf 方法，

  public static Integer valueOf(int i) {
     assert IntegerCache.high>= 127;
     if (i >= IntegerCache.low&& i <= IntegerCache.high)
     return IntegerCache.cache[i+ (-IntegerCache.low)];
     return new Integer(i); }

这个方法就是返回一个 Integer 对象，只是在返回之前，看作了一个判断，判断当前 i 的值是否在 [-128,127] 区别，且 IntegerCache 中是否存在此对象，如果存在，则直接返回引用，否则，创建一个新的对象。
在这里的话，因为程序初次运行，没有 59 ，所以，直接创建了一个新的对象。
int i02=59 ，这是一个基本类型，存储在栈中。
Integer i03 =Integer.valueOf(59); 因为 IntegerCache 中已经存在此对象，所以，直接返回引用。
Integer i04 = **new **Integer(59) ；直接创建一个新的对象。
System. *out *.println(i01== i02); i01 是 Integer 对象， i02 是 int ，这里比较的不是地址，而是值。 Integer 会自动拆箱成 int ，然后进行值的比较。所以，为真。
System. *out *.println(i01== i03); 因为 i03 返回的是 i01 的引用，所以，为真。
System. *out *.println(i03==i04); 因为 i04 是重新创建的对象，所以 i03,i04 是指向不同的对象，因此比较结果为假。
System. *out *.println(i02== i04); 因为 i02 是基本类型，所以此时 i04 会自动拆箱，进行值比较，所以，结果为真。

---

5.java的引用和c++的指针有什么区别

共同点：Java的引用和c++的指针都是指向一块内存地址的，通过引用或指针来完成对内存数据的操作。

区别

• （1） 类型：引用其值为地址的数据元素，Java封装了的地址，可以转成字符串查看 ，长度可以不用关心。c++指针是一个地址的变量，长度一般是计算机字长，可以认为是个int；

• （2） 所占内存：引用声明时没有实体，不占空间。c++指针如果声明够才会复制，如果用不到不会分配内存。
• （3） 类型转换：引用的类型转换也可能不成功，运行时抛出异常或者变异不能通过。c++指针只是个内存地址，指向哪里对程序来说都还是一个地址。
• （4） 初始值：引用初始值为Java关键字null，c++指针是int；如果不初始化指针那么他的值就不是固定的，这很危险。
• （5） 计算：引用是不可以计算的。C++指针是int，它可以计算，如++，——，所以经常用指针来代替数组下标。
• （6） 控制：引用不可以计算，所以它只能在自己的程序中，可以被控制。C++指针是内存地址，可以被计算，所以它有可能指向一个不属于自己程序使用的内存地址，对于其他程序来说是很危险的，对自己程序来说也不容易控制。
• （7） 内存泄漏： Java引用不会产生内存泄漏，c++指针使用容易产生内存泄漏，所以需要及时回收。
• （8）作为参数：Java方法参数知识传值，引用作为参数使用时，回给函数内引用的值得copy，所以在函数内交换两个引用参数是内有意义的因为函数值交换参数的copy值，但是在函数内改变一个引用参数的属性是有意义的，因为引用参数copy所引用的对象和引用参数是同一个对象。
  c++指针作为参数给函数使用，实际就是它所指的地址被函数操作。相关操作都直接作用到指针所指向的地址。

总而言之：Java的引用更安全、方便，但没有C++指针那么灵活，算是对指针的一种包装和改进。

---

6.简述Java中的main方法

main方法是Java程序的执行入口，它是一个定义在类中的、公开的、静态的、无返回值的、参数为一个字符串数组的方法、他的参数args与执行参数一一对应。
扩展：
给main函数传参的两种方法：
1.控制台通过 Java 类名 参数1 参数2 参数3、、、
2.通过其他类调用main方法直接传参

---

7.Java中equals和==的区别是什么？

【答案】

“==”运用在基本数据类型的时候，通过比较它们实际的值来判定是否相同；而用于比较引用类型的时候，则是比较两个引用的地址是否相等，也就是是否指向同一个对象

---

equals方法是Java.lang.Object的方法，也就是所有Java类都会有的方法。它可以被程序员覆盖重写，通过自定义方法来判定两个对象是否相等。对于String类来说，他的equals方法用来比较字符串的序列是否完全相等。

示例代码：

public class M {
public static void main(String[] args) {
String a="123";
String b="123";
String c=new String("123");

System.out.println(a==b);
System.out.println(a==c);
System.out.println(a.equals(c));
}
}

输出结果：

---

8.Java提供了几种循环结构？他们的各自特点是什么？

• 第一种:for循环
  　循环结构for语句的格式：
  　　for(初始化表达式;条件表达式;循环后的操作表达式) {
  　　　　　循环体;
  　　　}

• 第二种while语句
  　　循环结构while语句的格式：
  　　初始化语句;
  　　while(判断条件语句) {
  　　　　　　循环体语句;
  　　　　　　控制条件语句;
  　　　}
• 第三种do....while语句
  　　循环结构do...while语句的格式：
  　　初始化语句;
  　　　　do {
  　　　　　　循环体语句;
  　　　　　　控制条件语句;
  　　　　}while(判断条件语句);

总结:三种循环语句的区别:
1.do...while循环至少执行一次循环体.　　
2.而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句.*