Java基础（备忘录）

一、

1.成员函数被重载的特征：

（1）相同的范围（在同一个类中）

（2）函数名相同

（3）参数不同

（4）virtual关键字可有可无

2.覆盖的特征：

（1）不同的范围（分别位于派生类与基类）

（2）函数名相同

（3）参数相同

（4）基类函数必须有virtual关键字

3.静态方法不能被覆盖成非静态的方法

二、

class Parent {

public static String staticname = "parentStaticname";

public String name = "Parent";

public String getName(){

return name;

}

}

class Child extends Parent {

public static String staticname = "childStaticname";

public String name = "child";

public String getName(){

return name;

}

public String getchildName(){

return name;

}

}

public class Test {

public static void main(String[] args) {

Parent parent;

Child child;

child = new Child();

parent = (Child)child;

System.out.println(child.getClass());

System.out.println(child.name);

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

System.out.println(parent.getClass());

System.out.println(parent.name);

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

System.out.println(child.staticname);

System.out.println(parent.staticname);

}

}

运行结果：

class qg.java.Child

child

child

class qg.java.Child

Parent

child

childStaticname

parentStaticname

三、

1.匿名内部类是没有名字的内部类，不能继承其它类，但可以作为一个接口，由另一个内部类实现

2.final类是不可以被继承，不可以子类化，没有更多的限制，所有方法都默认为final，为方法添加final没有意义

3.抽象类是可以声明，但不可以实例化；

4.被abstract修饰的方法为抽象方法，抽象方法是不可以有实体的；

5.抽象类中可以有非抽象的方法，非抽象的方法是必须有实体的；

6.抽象类中如果全是抽象方法，就变成了接口

7.在abstract class
中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是
static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。

8
.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。

9.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

10.接口中的方法默认都是 public,abstract 类型的。

四、

定义在类中的变量会被赋予一个默认的值

下面代码是正确的：

public class Pvf {

static boolean Paddy;

public static void main(String argv[]) {

System.out.println(Paddy);

}

}

输出结果是：false

如果Paddy没有static修饰，则编译出错。

五、

1.String 与 char 之间的转换

String s = "hello";

char c[] = {'h','e','l','l','o'};

// String 转换成char

char ch[] = s.toCharArray();

// char 转换为string

String str = new String(c);

2.StringBuffer跟String

（1）String的创建

String str = "Hello"；

JVM先根据内容"Hello"查找对象，如果没有找到，则在堆（heap）上创建新对象，并赋予str，否则使用已经存在的对象

String s = new String("Hello");

JVM直接在heap上创建新的对象，所以在heap中会出现内容相同，地址不同的String对象

（2）String的比较

”==“比较的是地址

”equal“比较的是内容

（3）intern()方法：查找内容相同的字符串

String s1 = "Hello"；// 创建对象（1）

String s2 = new String("Hello"); // 将pool中的”Hello“对象复制一份放到heap中，再赋给s2

s2 = s2.intern(); // 找到对象（1），并赋给s2

s1 == s2; // true 此时s1，s2同指对象（1）

3.String与StringBuffer效率比较

String s = "s1";

s += "s2";

s += "s3";

因为String是不可变对象，每次”+=“操作都会构造新的String对象

String str = "hello" + "world"; // 只创建一个String对象

StringBuffer内部实现是char数组，默认初始化长度是16，每当字符串长度大于char数组长度时，JVM会构造更大的新数字，并将原先的数组内容复制到新数组。

4.下面代码创建了几个对象？

String A,B,C;

A = "a"; // 1个（1）

B = "b"; // 1个

A = A + B; // （1）成为垃圾，被回收 1个 ”ab“

StringBuffer D = new StringBuffer("abc"); // 2个 "abc"和”abc“的复制

D = D.append("567"); // 1个 ”567“ StringBuffer的特点是改变对象本身而不是创建新的对象，append是对同一个对象进行处理