Java面向对象总结(一)_java talk函数-优快云博客

本文深入解析了Java中的关键概念，包括super与this的区别、访问修饰符的作用范围、事件委托及垃圾回收机制、多重循环的退出策略、序列化的实现、排序算法、Overload与Override的区别、final关键字的使用、序列化的实现方法、集合框架中的比较接口实现、日期操作等。

1.super和this的区别

1)super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）

2)this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
3)super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）

4)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

5）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

　　 6）super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。

　　 7）super()和this()均需放在构造方法内第一行。

　　 8）尽管可以用this调用一个构造器，但却不能调用两个。

　　 9）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。（不可能都同时放在第一行）

　　 10）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。

　　 11）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

※转载自http://blog.youkuaiyun.com/anmei2010/article/details/4093118

2.作用域public,protected,private,以及不写时的区别？

public：无论是谁，无论在哪里，都可以访问该成员。

protected（继承访问权限）：权限赋予派生类而不是所有类，protected也提供包访问权限。

不写时（包访问权限）：当前的包中的所有其他类对那个成员都有访问权限，但对于这个包之外的所有类，这个成员是private。

private：除了包含该成员的类外，其他任何类都无法访问这个成员。

权限修饰符	同一类	同一包	不同包的子类	所有类
public	√	√	√	√
protected	√	√	√
默认的	√	√
private	√

3.JAVA的事件委托机制和垃圾回收机制

事件委托机制：不懂

垃圾回收机制：垃圾回收只与内存有关。垃圾收集是将分配给对象但不再使用的内存回收或释放的过程。如果一个对象没有指向它的引用或者其赋值为null,则这对象适合进行垃圾回收。

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

用break; return 方法。

5. 什么是java序列化，如何实现java序列化？(写一个实例)

序列化：将那些实现了Serializable接口的对象转换成一个字节序列，并能够在以后将这个字节序列完全恢复为原来的对象。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Random;

public class Worm implements Serializable {

    private static final long serialVersionUID = -7743560839691015997L;

    private static Random rand = new Random();

    int data;

    Worm() {
        data = rand.nextInt(999);
    }

    @Override
    public String toString() {
        return String.valueOf(data);
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        FileOutputStream fos = new FileOutputStream("t.tmp");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        Worm w = new Worm();
        oos.writeObject(w);
        System.out.println("data:" + w);
        FileInputStream fis = new FileInputStream("t.tmp");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Worm w1 = (Worm) ois.readObject();
        System.out.println("i:" + w1);
    }

}

6. 排序都有哪几种方法？请列举。用JAVA实现一个快速排序？

插入排序（直接插入排序、希尔排序）

直接插入排序：每次从无序表中取出第一个元素，把它插入到有序表的合适位置，使有序表仍然有序。

希尔排序：

7.Overload和Override的区别。Overload的方法是否可以改变返回值的类型?

重写Override，子类覆盖父类的方法，将子类传与父类的引用调用的还是子类的方法。（方法名和参数都相同）

重载Overload，一个类多个方法，名称相同，参数个数类型不同。（最常见的重载的例子就是类的构造函数）

Overload 的方法是可以改变返回值的类型。

8. Final

数据：常量，final与final static的区别只有在运行时才会显现，static在装载时已经初始化，而不是每次创建新对象时都初始化。

参数：可以读取参数，但无法修改参数。

方法：不能被覆盖。

类：禁止继承。

9.JAVA类实现序列化的方法(二种)

Serializable接口

Externalizable接口：调用writeObject()时，要调用writeExternal()；调用readObject()时，先调用默认的构造器（构造器是public的），再调用readExternal()。

10.如在COLLECTION框架中，实现比较要实现什么样的接口？

Collection 框架中实现比较要实现Comparable 接口和Comparator 接口

11.Java编程,打印昨天的当前时刻

import java.util.Calendar;

public class YesterdayCurrent {

    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DATE, -1);
        System.out.println(cal.getTime());
    }

}
//Mon Apr 08 16:23:58 CST 2013

12. 指出下面程序的运行结果。

class A {
    static {
        System.out.print("1");
    }

    public A() {
        System.out.print("2");
    }
}

class B extends A {
    static {
        System.out.print("a");
    }

    public B() {
        System.out.print("b");
    }
}

public class Hello {
    public static void main(String[] ars) {
        A ab = new B();
        ab = new B();
    }
}
//1a2b2b

注:类的static 代码段,可以看作是类首次加载(被虚拟机加载)执行的代码,而对于类的加载,首先要执行其基类的构造,再执行其本身的构造。

静态代码块：在这个类第一次被调用或实例化的时候就会被执行。
静态代码块只会执行一次，一般会用来初始化一些值，并且在所有对象中全局共享。

13.抽象类和接口的区别？

(1)接口可以被多重implements,抽象类只能被单一extends
(2)接口只有定义,抽象类可以有定义和实现
(3)接口的字段定义默认为:public static final, 抽象类字段默认是"friendly"(本包
可见)

(4)接口是一种特殊形式的抽象类

14.Java返射机制

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

class Actor {

}

class Performance {

    public Integer i;

    public Actor actor;

    public Performance() {

    }

    public Performance(Integer i) {

    }

    public String talkshow(Double d) {
        System.out.println(d + " minutes later TALKSHOW IS COMING");
        return null;
    }

}

public class ShowClass {

    public static void main(String[] args) {
        try {
            // 得到Class的三个方式
            Class<?> c = Class.forName("JAVAConclusion.Performance");// ?表示通配符，非具体的类引用
            Class<Performance> c1 = Performance.class;
            Class<? extends Performance> c2 = new Performance().getClass();// 该类型的任何子类型

            for (Constructor<?> cons : c.getConstructors()) {
                System.out.println("构造方法: " + cons.toString() + " ,MODIFIER:" + Modifier.toString(cons.getModifiers()));
            }
            for (Field field : c1.getFields()) {
                System.out.println("字段: " + field.toString());
            }
            for (Method method : c2.getMethods()) {
                if (method.getName().equals("talkshow")) {
                    System.out.println("方法: " + method.toString());
                    try {
                        method.invoke(new Performance(), 9.9);// 通过method.invoke(实例,参数值数组)唤醒方法
                    } catch (IllegalArgumentException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    }
                }
            }

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}
/*
输出结果：
构造方法: public JAVAConclusion.Performance() ,MODIFIER:public
构造方法: public JAVAConclusion.Performance(java.lang.Integer) ,MODIFIER:public
字段: public java.lang.Integer JAVAConclusion.Performance.i
字段: public JAVAConclusion.Actor JAVAConclusion.Performance.actor
方法: public java.lang.String JAVAConclusion.Performance.talkshow(java.lang.Double)
9.9 minutes later TALKSHOW IS COMING
*/

15.如何获取某个日期是当月的最后一天？

import java.util.Calendar;

public class IsLastDay {

    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR, 2013);
        c.set(Calendar.MONTH, Calendar.JANUARY);
        c.set(Calendar.DAY_OF_MONTH, 31);

        Calendar c1 = (Calendar) c.clone();

        System.out.println(c.get(Calendar.YEAR) + " " + (c.get(Calendar.MONTH) + 1) + " "
                + c.get(Calendar.DAY_OF_MONTH));
        System.out.println(c1.get(Calendar.YEAR) + " " + (c1.get(Calendar.MONTH) + 1) + " "
                + c1.get(Calendar.DAY_OF_MONTH));

        c.add(Calendar.DAY_OF_MONTH, 1);
        System.out.println(c.get(Calendar.YEAR) + " " + (c.get(Calendar.MONTH) + 1) + " "
                + c.get(Calendar.DAY_OF_MONTH));
        if (c.get(Calendar.MONTH) == c1.get(Calendar.MONTH)) {
            System.out.println("NOT LAST DAY");
        } else {
            System.out.println("LAST DAY");
        }
    }

}
/*
输出结果：
2013 1 31
2013 1 31
2013 2 1
LAST DAY
*/