常见笔试面试的一些原理

1.字符串相关

package com.test;

public class StringTest

{

public static void main(String[] args)

{

String s = new String("abc");//生成两个对象，String pool中一个，堆中一个

String s1 = "abc";//没有生成对象

String s2 = new String("abc");//堆中生成一个对象

System.out.println(s == s1);//false

System.out.println(s == s2);//false

System.out.println(s1 == s2);//false

System.out.println(s == s.intern());//false

System.out.println(s1 == s1.intern());//true

System.out.println(s.intern() == s2.intern());//true

String hello = "hello";

String hel = "hel";

String lo = "lo";

System.out.println(hello == "hel" + "lo");//true

System.out.println(hello == "hel" + lo);//false

}

}

输出：

false

false

false

false

true

true

true

false

2.参数传递

package com.test;

public class ParamTest

{

public void changeInt(int a)

{

a = 3;

}

public void changePoint(Point point)

{

point.x = 5;

point.y = 6;

}

public void changeString(String str)

{

str = "abc";

}

public static void main(String[] args)

{

String str = "xyz";

ParamTest pt = new ParamTest();

pt.changeString(str);

System.out.println(str);

int a = 1;

ParamTest pt1 = new ParamTest();

pt1.changeInt(a);

System.out.println(a);

Point point = new Point(1,2);

ParamTest pt2 = new ParamTest();

pt2.changePoint(point);

System.out.println(point.x);

System.out.println(point.y);

}

}

class Point

{

int x;

int y;

public Point(int x, int y)

{

this.x = x;

this.y = y;

}

}

输出：

xyz

1

5

6

在java中，不管是原生数据类型，还是引用类型，都是值传递

3.静态变量

package com.test;

public class StaticTest

{

private static StaticTest st = new StaticTest();

public static int count1;

public static int count2 = 0;

private StaticTest()

{

count1++;

count2++;

}

public static StaticTest getInstance()

{

return st;

}

public static void main(String[] args)

{

StaticTest st = StaticTest.getInstance();

System.out.println("count1: " + st.count1);

System.out.println("count2: " + st.count2);

}

}

输出：

count1: 1

count2: 0

静态变量从上往下依次执行，从main函数开始，执行getInstance方法时，先执行private static StaticTest st = new StaticTest(); ，new StaticTest();给count1,count2赋值都为1，然后执行

public static int count1;，只是定义一个变量，跳过，执行 public static int count2 = 0;给count2赋值为0

4.父子类的静态块和构造方法的执行顺序

package com.test;

public class OrderTest

{

public static void main(String[] args)

{

new Child("abc");

}

}

class Parent

{

static String name = "hello";

static

{

System.out.println("parent static block");

}

public Parent(String name)

{

System.out.println("parent constructor");

}

}

class Child extends Parent

{

static String childName = "world";

static

{

System.out.println("child static block");

}

public Child(String str)

{

super(str);

System.out.println("child constructor");

}

}

输出：

parent static block

child static block

parent constructor

child constructor

生成子类对象是，父子类的静态块和构造方法的执行顺序是先父类的静态块，再子类的静态块，再父类的构造方法，再子类的构造方法，

子类的构造方法，不管带不带参数，总是先调用父类的不带参数的构造方法，如果父类没有不带参数的构造方法，子类应显示的调用父类的构造方法

5.关于java中的方法重写（override）

1>.子类中的方法与父类中的方法有相同的返回类型，相同的方法名称，相同的参数类表

2>.子类中的方法的访问级别不能低于父类中该方法的访问级别

3>.子类中方法抛出的异常范围不能大于父类中方法抛出的异常范围

6.能否将name属性改成world

package com.test;

public class PrivateTest

{

private String name = "hello";

public String getName()

{

return name;

}

}

修改代码（java 反射 reflect）

package com.test;

import java.lang.reflect.Field;

public class ReflectionTest

{

public static void main(String[] args) throws Exception

{

PrivateTest pt = new PrivateTest();

Class<?> clazz = PrivateTest.class;

Field field = clazz.getDeclaredField("name");

field.setAccessible(true);

field.set(pt,"world");

System.out.println(pt.getName());

}

}

获得某个类class对象的方法

1.使用类的.class语法

2.通过类的对象的getClass()方法

3.通过Class对象的forName方法

4.对于包装类，可以通过.TYPE语法方式

7.public class Test{

private final int a;

private String name;

public Test(){

a = 3;

}

public Test(String name){

//a = 3;

this.name = name;

}

}

编译能否通过，为什么

对于final类型的成员变量的初始化方式

1> 声明变量是直接赋值

2> 在构造方法中完成赋值，如果一个类有多个构造方法，就要保证在每个构造方法中对final类型的

成员变量的赋值

解决方法，1 private final int a=0;

2 a = 3;

this.name = name;

public class Test{

private static final int a=3;

private String name;

public Test(){

//a = 3;

}

public Test(String name){

//a = 3;

this.name = name;

}

}

对于static final 类型的变量只能在声明的时候给其赋值

public class Test{

public static final StringBuffer s = new StringBuffer();

public static void main(String[] args){

s.append("hello");

}

编译可以通过，对于final类型引用本身不能变，不能指向其他对象，所指向的对象可以变

}