java编程语言的特点、优势？

简单，稳定。面向对象。跨平台性。解释型语言(非纯解释性语言,先编译后运行)。多线程。多态性，可靠，安全。谈谈你对Linux操作系统的认识?和windows有什么区别?常用命令有哪些?

Linux操作系统开源的操作系统、免费，主要用于服务器端操作系统,Java主要是服务器端开发，所以最终部署环境一般都是Linux.

Linux与Windows目录结构的区别:
文件系统不同:     Linux:目录      Windows:盘符
外部设备映射不同: Linux:挂载点    Windows:盘符
安全级别不同:     Linux:高        Windows:低

Linux常用命令:
pwd:显示当前工作目录
ls:查看当前工作目录的内容
cd:改变当前工作目录 . :当前目录 .. :上一级目录

Java的运行过程?

java遵循先编译后运行的过程,首先通过javac命令将JAVA源程序.java文件编译为JAVA字节码.class文件，而后通过java命令启动JVM，由JVM来加载.class文件并运行.class文件。

一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。

public class base{

}
class A{

}
class B{

}

简述：JDK，JRE,JVM的关系？

JDK：Java开发工具包，包含编写Java程序所必须的编译、运行等开发工具以及JRE。JRE：Java运行环境，提供了运行Java应用程序所必须的软件环境，包含有Java虚拟机（JVM）和丰富的系统类库。

JVM：Java虚拟机，提供了字节码文件（.class）的运行环境支持.

java的八大基本类型以及各自的字节数和位数?

1字节=8位

整数类型: byte(1字节) short(2字节) int(4字节) long(8字节) 浮点类型: fioat(4字节) double(8字节)char(2字节)boolean(1字节) 基本类型之间的转换规则?

不同的基本类型直接可以互相转换:

自动类型转换(隐式类型转换) :从小类型到大类型可以自动完成。类型的大小关系如下所示

byte-->short-->int-->long-->float-->doublechar-->int 强制转换: 从小类型到大类型需要相纸转换符:

(需要转换成的类型)变量但这样转换可能会造成精度损失或者溢出

整数类型等号右边默认是int类型,如果想要表示long类型,需要在值后面加L浮点型等号右边默认是double类型,如果想要表示float类型,需要在值后面加F

short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

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

对于short s1 = 1; s1 += 1;由于 +=是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。

Java有没有goto关键字?

有,goto是java中的保留字，现在没有在java中使用。

&和&&的区别?

&和&&都可以用作逻辑与的运算符

&:非短路与,&左右两侧表达式如果为boolean类型,那么表示的是非短路与,左侧表达式为false时还会计算右侧表达式,若&两侧非boolean类型,那么是位与运算,获取来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。

&&:短路与,表达式左侧如果为false,表达式右侧就不再进行运算.

在JAVA中如何跳出当前的多重嵌套循环？

在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break语句，即可跳出外层循环。

ok;
for(int i=0; i<10; i++){
    for(int j=0; i<10;j++)
        System.out.println("i="+i+",j="+j)
            if(j==5)
                break ok;
}

Math.round(11.5)等于多少? Math.round(-11.5)等于多少?

Math类中提供了三个与取整有关的方法：ceil、floor、round

ceil的英文意义是天花板，该方法就表示向上取整:

Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11

floor的英文意义是地板，该方法就表示向下取整:

Math.floor(11.6)的结果为11,Math.floor(-11.6)的结果是-12；

round方法:它表示“四舍五入”，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。

switch 语句能否作用在byte上,能否作用在long上,能否作用在String上 ?

在switch(expr1)中,expr1只能是一个整数表达式,整数表达式可以是int基本类型或Integer包装类型,由于byte,short,char都可以自动转换成int型,所以可以使用.

long类型由于不能自动转换成int类型,所以不能使用.

关于字符串类型,在JDK是1.7版本之前，swicth case中不可以使用字符串,但在JDK1.7之后是可以用字符串的，这是最新版本新加入的特性.

break,continue,return 的区别? (面)

break:跳出循环(只能跳出一层循环)

continue:跳过本次循环体重剩余的语句进入下一次循环

return:结束当前方法

使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的,另外final修饰的方法不能被重写，修饰的类不可被继承，修饰的成员变量不可改变.

比如:final StringBuffer a=new StringBuffer("abc");

执行如下语句将报编译错误:

a=new StringBuffer("123");

但是,执行如下语句则可以通过编译:

a.append("def");

内存管理？

JVM会将申请到的内存从逻辑上划分为三个区域：堆、栈、方法区。这三个区域分别用于存储不同的数据。

堆：用于存储使用new关键字所创建的对象以及对象的属性成员变量。

栈：用于存储程序运行时在方法中声明的所有的局部变量。

方法区：用于存放类的各种信息（包括方法）都在方法区存储。

成员变量和局部变量的定义以及生命周期?

局部变量：
1) 定义在方法中；

2) 没有默认值，必须自行设定初始值；

3) 方法被调用时，存在栈中，方法调用结束时局部变量从栈中清除；

成员变量：
1) 定义在类中，方法外；

2) 由系统设定默认初始值，可以不显式初始化；

3) 所在类被实例化后，存在堆中，对象被回收时，成员变量失效；

static关键字可以修饰什么?

static修饰的变量是静态变量,修饰的方法是静态方法,可以和final共同修饰常量,也还可以单独作为静态块存在.

static修饰的属性,方法都是独一份,可以被多个对象共用,因为与对象无关,属于类,所以直接用类名调用.

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

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

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

静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

冒泡排序的原理及代码实现?

冒泡的原理:
   1)假设有4个数,4个数冒三轮

   2)每一轮都是从第1个元素开始比，

     每一次都是和它的下一个元素比

       3)冒出来的就不带它玩了

代码实现:

需要用到双层for循环:

 int arr[]={10,9,1,20,19,30,5};
 public static void main(String[] args) {
	for(int i=0;iarr[j+1]){
					int t=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=t;
				}}}
		for(int i=0;i

方法的定义,返回值?

方法是封装特定的逻辑功能,一个方法只干一件事,可以被反复调用多次,避免代码重复，有利于代码维护、有利于团队协作开发.

方法包含:修饰词,返回值类型,方法名,参数列表,方法体,如下:

有返回值的方法可以使用return返回:

return 值; 结束方法的执行返回结果给调用方

return; 结束方法的执行

Overload和Override的区别？

Overload是重载的意思，Override是覆盖的意思，也就是重写。

重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。

重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。

重写的两同两小一大规则?

重写要遵循"两同两小一大"原则:

两同:1)方法名相同 2)参数列表相同

两小: 1)子类方法的返回值类型小于或等于父类的

1.1)void时必须相等

1.2)基本类型时必须相等

1.3)引用类型时小于或相等:父类大,子类小

2)子类抛出的异常小于或等于父类的

一大:子类方法的访问权限大于或等于父类的

什么是类?什么是对象?

现实世界是由很多很多对象组成的,基于对象抽出了类

对象:真实存在的单个个体

类:类型、类别，代表一类个体, 一个类可以创建多个对象:同一类型的对象，结构相同，数据不同.

类是对象的模板，对象是类的具体的实例

类中可以包含:

所有对象所共有的属性/特征(静的)---------成员变量
所有对象所共有的行为(动的)--------------方法

比如:有一个人这个类,类中包含有人的一些特征(成员变量):年龄,性别,名字等,还有一些行为(方法):吃饭,睡觉等,通过这个类可以创建出张三,李四等很多个实例对象.

构造方法?

构造方法也叫构造函数、构造器、构建器

常常用于给成员变量赋初值,与类同名，没有返回值类型,在创建对象时被自动调用
若自己不写构造，则编译器默认提供一个无参构造,若写了构造，则不再默认提供
构造方法可以重载,但不可被继承,不可以被重写.

构造器Constructor是否可被重写override?

构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。

this关键字的用法?

this:指代当前对象，哪个对象调指的就是哪个对象,只能用在方法中，方法中访问成员变量之前默认有个this.

this的用法:

this.成员变量名------------访问成员变量
this.方法名()--------------调用方法
this()---------------------调用构造方法

super关键字的用法?

super:指代当前对象的父类对象

super的用法:

super.成员变量名----------访问父类的成员变量
super.方法名()------------调用父类的方法
super()-------------------调用父类的构造方法

注意: 构造子类之前必须先构造父类,子类构造方法中若没有调用父类的构造方法，则默认super()调父类的无参构造，若子类构造方法中调用了父类的构造方法，则不再默认提供super()调父类构造必须位于子类构造方法的第一句,默认存在.

且不能与this()同时使用,因为this()和super()都要求存在构造方法的第一行,会产生竞争,编译错误.

向上造型?

父类型的引用指向子类的对象,多态的一种体现,能点出来什么，看引用的类型,调用方法看引用指向的对象.

面向对象三大特征?

封装,继承,多态

封装:把描述一个对象的属性和行为封装成一个类,把具体的业务逻辑功能实现封装成一个方法,其次封装的意义还有效的保护属性通过访问修饰符私有化属性(成员变量),公有化方法.

继承:实现代码的复用,所有的子类所共有的行为和属性抽取为一个父类,所有的子类继承该类可具备父类的属性和行为,继承具有单一性和传递性.

多态:程序中定义的引用类型变量所指向的具体类型和调用具体的方法在编译期无法确定,而是在运行期才能确定该引用类型变量指向具体哪个对象而调用在哪个类中声明的方法.

多态的表现形式有强制类型转换,向上造型等,多态可分为行为多态和对象多态:

行为多态:同一个run(){}方法,不同的对象调用时会有不同的实现,猫调用时是跑,鱼调用时是游,鸟调用时是飞.

对象多态:同一个对象,可以被造型为不同的类型,比如同一个人对象,可以被造型为儿子,父亲,员工等.

java中实现多态的机制是什么？

靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

访问修饰符？
public:公共的，任何类
protected:受保护的，本类、子类、同包类
默认的:什么也不写，本类、同包类
private:私有的，本类

abstract class抽象类和interface接口有什么区别?

含有abstract修饰符的class即为抽象类，抽象类不能创建的实例对象。含有抽象方法的类必须定义为abstract class.

接口（interface）可以说成是一种特殊的抽象类，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。

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

抽象类可以有构造方法，接口中不能有构造方法。
抽象类中可以有普通成员变量，接口中没有普通成员变量
抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse不报错，但也不行,默认类型子类不能继承），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型.
抽象类中可以包含静态方法，接口中JDK1.8之前不可以有不能包含静态方法和成员方法,JDK1.8之后可以包含.但成员方法必须使用default修饰
抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
一个类可以实现多个接口,用逗号隔开，但只能继承一个抽象类,接口不可以实现接口,但可以继承接口并且可以继承多个接口,用逗号隔开.

内部类可以引用它的包含类的成员吗？有没有什么限制?

完全可以。如果不是静态内部类，那没有什么限制！

如果是静态内部类,那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员。

什么是匿名内部类?
若想创建一个类(子类)的对象，并且对象只被创建一个，此时该类不必命名，称之为匿名内部类
匿名内部类中访问外部的变量，该变量必须是final的.

super.getClass()方法调用结果?
下面程序的输出结果是多少？

public class Test extends Date{

       public static void main(String[] args) {

              new Test().test();

       }

       public void test(){

              System.out.println(super.getClass().getName());

       }

}

很奇怪，结果是Test

在test方法中，直接调用getClass().getName()方法，返回的是Test类名

原因在于:由于getClass()在Object类中定义成了final，子类不能覆盖该方法，所以，在test方法中调用getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用super.getClass().getName()方法，所以，super.getClass().getName()方法返回的也应该是Test。

如果想得到父类的名称，应该用如下代码：

getClass().getSuperClass().getName();

一个对象在什么情况下会被GC回收？

当这个对象没有被任何引用指向或者引用为NULL时会被GC回收。

JAVA中调用方法传递方式是值传递还是引用传递?

在java中调用方法传递的不管基本类型的值还是引用类型的引用,都是值传递,有切只要一种传递方式:值传递

调用方法传入基本类型的值时传递的是值的一份拷贝,传入引用类型的引用时传递的也是引用中存储的地址值,都是值传递,都是在栈中操作的.

String是最基本的数据类型吗?

不属于，基本数据类型包括byte、int、char、long、float、double、boolean和short。

java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类。

String这个类能否被继承?

不可以,String类是final类型的，因此不可以继承这个类、不能修改这个类.

如何将GBK编码的字符串转换成ISO8859-1编码的字符串?

String类有一个重载的构造方法:

String(byte bytes[], String charsetName)

第一个参数为一个byte数组,第二个参数为指定的字符集类型

String str="Hello";
String str1=new String(str.getBytes("GBK"),"ISO8859-1");
System.out.println(str1);

String,StringBuffer,StringBuilder的区别?
String类是final修饰的,该类所表示的字符串对象不可变,一旦发生改变即创建新对象, 当我们通过字面量，常量来初始化一个字符串时，JVM首先会从字符串的常量池(一个JVM内部维护的内存区域，用来保存已经创建过的字符串对象)中查询用来保存该字符串的对象是否存在，若存在则直接引用，若不存在则创建该字符串对象并存入常量池，然后引用它.
StringBuffer和StringBuilder是可变字符串对象,对字符串的修改操作不会创建新对象,都是在原有对象基础上进行修改,内部有很多操作字符串的方法,比如append()等.另外StringBuffer是线程安全的，同步处理的，性能稍慢；StringBuilder是非线程安全的，并发处理的，性能稍快。
String s="a"+"b"+"c"+"d"创建了几个对象?
创建了1个对象,编译器在编译时会先将4个单独的字符串编辑成一个"abcd"字符串.
String str=new String("abcdefg");创建了几个对象?
创建了两个对象,一个str引用指向堆内存中的String对象,另外一个则是String类有参构造方法中的直接量字符串对象,该字符串对象在字符串常量池中.

把创建的对象过程拆分成两部分就比较直观了:

String s="abcdefg";

String str=new String(s);

延伸问题:

如果在执行一次String str1=new String("abcdefg");此时共创建了几个对象?

上一次操作创建了2个对象,这一次操作创建了1个对象,一共3个.

因为在第一次常量池中已经有一个"abcdefg"字符串对象,第二个创建时并没有创建新的,而是拿过来直接用,只是创建了1个str1指向堆内存中的String对象,共3个.

补充:String对象的intern()方法会得到字符串对象在常量池中对应的引用(equals比较为true的字符串对象),如果常量池中没有该对应的字符串,则会把该字符串存入常量池,返回该字符串对象的引用.

它遵循对于任何两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true.

例如:

String str1 = "a";

String str2 = "b";

String str3 = "ab";

String str4 = str1 + str2;

String str5 = new String("ab");

System.out.println(str5.equals(str3));//true

System.out.println(str5 == str3);//false

System.out.println(str5.intern() == str3);//true

     System.out.println(str5.intern() == str4);//false

第一、str5.equals(str3)这个结果为true，因为字符串的值的内容相同。

第二、str5 == str3对比的是引用的地址是否相同，由于str5采用new String引用第地址不相同,所以结果为false。

第三、当str5调用intern的时候，会检查字符串池中是否含有该字符串。由于之前定义的str3已经进入字符串池中，所以会得到相同的引用,所以比较为true。

第四，当str4 = str1 + str2后，str4的值也为”ab”,但是在字符串拼接的规则里, 如果+号两边有一个是变量,就会去创建新对象,str4并没有引用常量池中的地址.而是自己创建了一个新"ab"对象放在堆内存.所以比较为flase

如何把一段逗号分割的字符串转换成一个数组?
String[] split(String regex):将字符串按照传入参数的规则进行拆分成字符串数组.
比如:

String str="java,php,c++,c#,web";

String [] array=str.split(",");

拆分后的结果为字符串数组.

final,finalize,finally的区别?
final:修饰符:
final修饰的类不能被继承,
final修饰的变量不可改变,在声明的同时初始化.
final修饰的方法不可被重写.
finalize:方法名
在垃圾回收器将内存中的没有引用指向的对象清空之前,调用finalize() 进行清理工作.
finally:异常处理中的程序块
在异常处理时,使用finally块来进行必要的清理工作,不论是否有异常发生,finally语句块中的语句都会被执行,如果发生了异常,则执行catch语句,再执行finally块.
String这个类常用的处理字符串的方法?
indexOf:检索指定字符在字符串中第一次出现的位置.
substring:用来截取当前字符串,含头不含尾
trim:去除字符串两边的空白
charAt:给定一个下标,获取该下标对应的字符
startsWith:是否以给定字符串开始.
endsWith:是否以给定字符串结尾
toUpperCase:将当前字符串引文部分全部转换为大写
toLowerCase:将当前字符串英文部分全部转换为小写
valueOf:将基本类型的值转换为字符串
StringBuilder这个类常用的处理字符串的方法?
append(String str)：追加字符串；
insert (int dstOffset，String s)：插入字符串；
delete(int start，int end)：删除字符串；
replace(int start，int end，String str): 替换字符串；
reverse()：字符串反转.
和equals方法究竟有什么区别？
   比较基本数据类型时比较的时值是否相等，比较引用类型时比较的是对象的地址值是
   否相同，也就是否是同一对象。
   未重写的equals方法调用的是Object的方法,用法==一样,重写后的equals方法是用
   于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的
   两个对象是独立的。例如对于下面的代码：
   String a=new String("foo");
   String b=new String("foo");
   两条new语句创建了两个对象，然后用a和b这两个变量分别指向了其中一个对象，
   这是两个不同的对象，它们的地址是不同的，所以表达式a==b将返回false，而这两
   个对象中的内容是相同的，所以，表达式a.equals(b)将返回true.
   String这个类重写过equals方法, StringBuffer,StringBuilder未重写过equals方法.
包装类的自动拆装箱？
   自动拆装箱是JDK1.5以后的一个新特性：
   基本类型转换为包装类叫自动装箱，比如int转换成Integer
   包装类转换成基本类型叫自动拆箱，比如Integer转换成int。
   将基本类型转换为包装类时，我们可以调用包装类的一个静态方法valueOf():
   Integer i = Integer.valueOf(1);
   Double d = Double.valueOf(1.1):
   将包装类转换为基本类型时，我们可以使用包装类的方法xxxValue()方法
   Integer i = new Integer(1);

   int n = i.intValue();

   Double d = new Double(1.1);

   double dn = d.doublevalue();

int i=128;如下情况的比较结果是?
              Integer i1=new Integer(i);

              Integer i2=new Integer(i);

              System.out.println(i1==i2);

              System.out.println(i1.equals(i2));

输出的结果是false   true

因为i1和i2使用new关键字new了两次,在堆内存中创建了2个对象,所以==比较为false,内容相同equals比较为true

        Integer i3=Integer.valueOf(i);

              Integer i4=Integer.valueOf(i);

              System.out.println(i3==i4);

              System.out.println(i3.equals(i4));

输出结果为false   true

在包装类的内存中有一块区域,缓存着Integer的byte范围内的值(-128~127),如果未超出此范围,则直接在该缓存区取值,并不会在堆中创建新对象,如果超出此范围则会在堆内存中创建新对象.
如上代码i=128超出了取值范围,则在i3和i4创建了两个对象,所以双等号比较为false,内容相同equals比较为true
注意:如果i=127,通过new关键字创建的对象也是两个对象,通过valueOf()创建的对象为同一个对象.
怎么把一个基本类型的值转换成字符串?
int a=100;

两种方式:

1)String str=a+"";

2)String str=String.valueOf(a);

反过来把一个字符串数值转成一个基本类型:

String str="100";

int a=Integer.parseInt(str);

数组有没有length()这个方法? String有没有length()这个方法？集合有没有length()这个方法?
数组没有length()这个方法，有length的属性.
String有length()这个方法.
集合没有length()方法,有size()方法.
Collection和 Collections的区别?
   Collection是集合类的上级接口，继承与他的接口主要有Set和List.
   List:称为可重复集, 重复元素指的是equals方法比较为true的元素
   Set:称为不可重复集, 该集合中是不能将相同的元素存入集合两次
   Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索
排序、线程安全化等操作。
两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
这句话是对的。首先看以下Person,只重写了equals方法时:

Java面试题

Linux与Windows目录结构的区别:
文件系统不同:     Linux:目录      Windows:盘符
外部设备映射不同: Linux:挂载点    Windows:盘符
安全级别不同:     Linux:高        Windows:低

Linux常用命令:
pwd:显示当前工作目录
ls:查看当前工作目录的内容
cd:改变当前工作目录 . :当前目录 .. :上一级目录

成员变量和局部变量的定义以及生命周期?

局部变量：
1) 定义在方法中；

2) 没有默认值，必须自行设定初始值；

3) 方法被调用时，存在栈中，方法调用结束时局部变量从栈中清除；

成员变量：
1) 定义在类中，方法外；

2) 由系统设定默认初始值，可以不显式初始化；

3) 所在类被实例化后，存在堆中，对象被回收时，成员变量失效；

冒泡排序的原理及代码实现?

冒泡的原理:
   1)假设有4个数,4个数冒三轮

   2)每一轮都是从第1个元素开始比，

     每一次都是和它的下一个元素比

       3)冒出来的就不带它玩了

访问修饰符？
public:公共的，任何类
protected:受保护的，本类、子类、同包类
默认的:什么也不写，本类、同包类
private:私有的，本类

什么是匿名内部类?
若想创建一个类(子类)的对象，并且对象只被创建一个，此时该类不必命名，称之为匿名内部类
匿名内部类中访问外部的变量，该变量必须是final的.

怎么把一个基本类型的值转换成字符串?
int a=100;

两种方式:

1)String str=a+"";

2)String str=String.valueOf(a);

反过来把一个字符串数值转成一个基本类型:

String str="100";

int a=Integer.parseInt(str);

两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
这句话是对的。首先看以下Person,只重写了equals方法时:

Java相关栏目本月热门文章

Java面试题

Linux与Windows目录结构的区别: 文件系统不同: Linux:目录 Windows:盘符外部设备映射不同: Linux:挂载点 Windows:盘符 安全级别不同: Linux:高 Windows:低

Linux常用命令: pwd:显示当前工作目录 ls:查看当前工作目录的内容 cd:改变当前工作目录 . :当前目录 .. :上一级目录

成员变量和局部变量的定义以及生命周期?

局部变量： 1) 定义在方法中； 2) 没有默认值，必须自行设定初始值； 3) 方法被调用时，存在栈中，方法调用结束时局部变量从栈中清除；

成员变量： 1) 定义在类中，方法外； 2) 由系统设定默认初始值，可以不显式初始化； 3) 所在类被实例化后，存在堆中，对象被回收时，成员变量失效；

冒泡排序的原理及代码实现?

冒泡的原理: 1)假设有4个数,4个数冒三轮 2)每一轮都是从第1个元素开始比， 每一次都是和它的下一个元素比 3)冒出来的就不带它玩了

访问修饰符？ public:公共的，任何类protected:受保护的，本类、子类、同包类默认的:什么也不写，本类、同包类private:私有的，本类

什么是匿名内部类? 若想创建一个类(子类)的对象，并且对象只被创建一个，此时该类不必命名，称 之为匿名内部类匿名内部类中访问外部的变量，该变量必须是final的.

怎么把一个基本类型的值转换成字符串? int a=100; 两种方式: 1)String str=a+""; 2)String str=String.valueOf(a); 反过来把一个字符串数值转成一个基本类型: String str="100"; int a=Integer.parseInt(str);

两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对? 这句话是对的。首先看以下Person,只重写了equals方法时:

Java相关栏目本月热门文章

Linux与Windows目录结构的区别:
文件系统不同: Linux:目录 Windows:盘符
外部设备映射不同: Linux:挂载点 Windows:盘符
安全级别不同: Linux:高 Windows:低

Linux常用命令:
pwd:显示当前工作目录
ls:查看当前工作目录的内容
cd:改变当前工作目录 . :当前目录 .. :上一级目录

局部变量：
1) 定义在方法中；

2) 没有默认值，必须自行设定初始值；

3) 方法被调用时，存在栈中，方法调用结束时局部变量从栈中清除；

成员变量：
1) 定义在类中，方法外；

2) 由系统设定默认初始值，可以不显式初始化；

3) 所在类被实例化后，存在堆中，对象被回收时，成员变量失效；

冒泡的原理:
1)假设有4个数,4个数冒三轮

2)每一轮都是从第1个元素开始比，

每一次都是和它的下一个元素比

3)冒出来的就不带它玩了

访问修饰符？
public:公共的，任何类
protected:受保护的，本类、子类、同包类
默认的:什么也不写，本类、同包类
private:私有的，本类

什么是匿名内部类?
若想创建一个类(子类)的对象，并且对象只被创建一个，此时该类不必命名，称之为匿名内部类
匿名内部类中访问外部的变量，该变量必须是final的.

怎么把一个基本类型的值转换成字符串?
int a=100;

两种方式:

1)String str=a+"";

2)String str=String.valueOf(a);

反过来把一个字符串数值转成一个基本类型:

String str="100";

int a=Integer.parseInt(str);

两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
这句话是对的。首先看以下Person,只重写了equals方法时: