Java细节.doc

public class Vehicle {
//startUp方法表示一般交通工具的启动功能
public void startUp()
{
System.out.println("一般交通工具的启动方法！！！");
}
}
//汽车类，其继承了交通工具类并覆盖了启动方法（startUp），
public class Car extends Vehicle{
//startUp方法表示一般交通工具的启动功能
public void startUp()
{
System.out.println("轿车的启动方法！！！");
}
}
public class Sample4_5 {
public static void main(String[] args)
{
//创建对象并调用方法
Vehicle v=new Car();
System.out.print("实际调用的方法为：");
v.startUp();
}
}
注意：当父类的引用指向子类对象时，若访问被重写的方法，则将访问被重新定义的子类中的方法。
public class Car {
String aMember="我是汽车类的成员变量";

}
public class Truck extends Car{
String aMember="我是卡车类的成员变量，汽车类也有";

}
public class Sample4_10 {
public static void main(String[] args) {
Car c = new Truck();
System.out.println("访问的成员为：" + c.aMember + "!");
//System.out.println("访问的成员为："+((Truck)c).aMember+"!");
}
}
注意：看似子类的属性和父类是一样的，但是这不是覆盖属性中没有覆盖的说法。虽然对象是子类Truck的，但打印的是父类Car的成员变量。对于成员变量的访问系统接受的是引用类型，引用是哪个类的，系统就访问哪个类的成员。(成员变量按引用的类型调用！！！)
注意：方法和成员变量的调用不一样，到底是调用哪个的，注意区分。
3.图形解析
父类
引用变量
子类对象
Car c = new Truck();

4.
public class Sample4_8 {
private int x, y;

public Sample4_8(int x, int y) {
this.x = x;
下面的构造函数调用上面的构造函数
this.y = y;
}

public Sample4_8() {
this(0, 0); //this（参数）调用本类中另一种形成的构造函数
}

public static void main(String srgs[]) {
Sample4_8 s = new Sample4_8();
System.out.println(s.x);
System.out.println(s.y);
}
}
注意：当一个类中有多个构造函数时，可以通过this关键字相互调用。根据参数的个数、类型，选择调用哪一个构造函数。
5.
public class Sample4_6 {
private String s = "haha";

public String getString() {
String s = "kaka";
System.out.println("方法中:" + s);
return this.s;
}

public static void main(String args[]) {
Sample4_6 g = new Sample4_6();
System.out.println(g.getString());
}
}
注意调用的成员变量！this是指当前对象。
6.
一个子类只能继承一个父类，一个父类可以有一个或多个子类。Java只支持单继承，但是可以通过接口，实现意义上的多继承。
父类的引用可以指向子类对象，即可以将子类对象看做父类对象。反之，子类的引用不能指向父类对象。
7.
public abstract class Car {
//定义抽象方法brake
public abstract void brake();
}
public class Truck extends Car{
// 实现brake方法
public void brake()
{
System.out.println("卡车刹车！！");
}
}
public class SUV extends Car {
// //实现brake方法
public void brake() {
System.out.println("正在SUV上刹车！！");
}
}
public class Sample4_18 {
public static void main(String[] args)
{
//声明Car引用c并将其指向Truck类的对象
Car c=new Truck();
Car c2=c;
Car c3=new Truck();
System.out.print("调用的方法为：");
//使用引用调用brake方法
c.brake();
c2.brake();
c3.brake();
/*上面3条语句调用的都是子类即Truck中的brake方法，这就是最上面所说的成员方法的调用。见最上面！(当父类的引用指向子类对象时，若访问被重写的方法，则将访问被重新定义的子类中的方法)*/
//将引用c指向Mini类的对象
c=new SUV();
System.out.print("调用的方法为：");
//使用引用c调用brake方法
c.brake();

}
}
注意：以上代码都是正确的。红色部分说明了一个对象可以有多个引用，但一个引用只能指向一个对象。
8.java中的main为什么是static?
《Java编程思想》有言：如果不需要内部类对象与其外围内对象之间有关系，那么可以将内部内声明为static。记住，普通的内部类对象隐式地保存了一个引用，指向创建它的外围对象……（详见：201页）
jvm装载的时候可以直接调用，否则还要new一个对象才能调用，多麻烦？
main函数其实也是所在类的一个方法，就比如一个类是test，那么该类的main其实就是test.main(String[] args)，众所周知如果一个方法不是静态的，则要先实例化该类，比如要这样 test t=new test();
然后才能调用 test.main();

而这对于运行一个程序的主函数来说是不现实的，所以比如把main函数定义为static，使test.main()可以直接被调用。

如果是动态的必须先实例化对象，才能访问。
但是main（）一般作为入口函数，通常是静态的，这样可以直接访问。
9. 抽象类和接口的区别
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口

接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，

另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。

还有，接口可以实现多重继承，而一个类只能继承一个超类，但可以通过继承多个接口实现多重继承，接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用.
如下给出两者的简单对比表格。

接口
抽象类
多继承
支持
不支持
类型限制
没有
有，只能是引用类型
方法实现
继承类型中必须给出方法实现
继承类中可以不给出
扩展性
比较麻烦
相对比较灵活
多层继承
比较麻烦，需要借助虚函数
比较灵活