《Java核心技术》复习笔记 - 第六章 接口与内部类

《Java核心技术》复习笔记 - 第六章 接口与内部类

1. 接口和抽象类的区别

2. Java不支持多重继承，但是引入了接口的概念，声明一个接口用关键字interface，实现接口用关键字implements，接口是可以继承的。接口绝不能含有实例域，也不能在接口中实现方法。接口中的所有方法自动为public，在实现接口时，必须把实现的方法声明为public，否则编译器认为该方法是包可见性，并可出一个警告。接口中可以包含常量，接口中的域被自动设为public static final。

3. Object有一个protected的clone方法，提供的克隆操作为浅拷贝，即没有拷贝对象所引用的对象。如果原始对象与浅拷贝对象共享的子对象是不可变的，将不会产生任何问题。但是更常见的是子对象是可变的，这时就要重新定义clone方法，以便提供深拷贝语义。由于Object提供的clone方法为protected，因此子类只能调用受保护的clone方法克隆它自己。为此，必须重新定义clone方法，并将他申明为public，这样才能让所有的方法克隆该类的对象。

import java.util.*;

/**
* This program demonstrates cloning.
* @version 1.10 2002-07-01
* @author Cay Horstmann
*/
public class CloneTest
{
public static void main(String[] args)
{
try
{
Employee original = new Employee("John Q. Public", 50000);
original.setHireDay(2000, 1, 1);
Employee copy = original.clone();
copy.raiseSalary(10);
copy.setHireDay(2002, 12, 31);
System.out.println("original=" + original);
System.out.println("copy=" + copy);
}
catch (CloneNotSupportedException e)
{
e.printStackTrace();
}
}
}

class Employee implements Cloneable
{
public Employee(String n, double s)
{
name = n;
salary = s;
hireDay = new Date();
}

public Employee clone() throws CloneNotSupportedException
{
// call Object.clone()
Employee cloned = (Employee) super.clone();

// clone mutable fields
cloned.hireDay = (Date) hireDay.clone();

return cloned;
}

/**
* Set the hire day to a given date.
* @param year the year of the hire day
* @param month the month of the hire day
* @param day the day of the hire day
*/
public void setHireDay(int year, int month, int day)
{
Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime();

// Example of instance field mutation
hireDay.setTime(newHireDay.getTime());
}

public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}

public String toString()
{
return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
}

private String name;
private double salary;
private Date hireDay;
}

4. 所有数组类型都包含一个clone方法，这个方法被设为public，而不是protected，可以利用这个方法创建一个包含所有数据元素拷贝的新数组。

5. 内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域。内部类对象有一个隐式引用，指向创建它的外部类对象。外围类的引用是在构造器中设置的，编译器会修改所有内部类的构造器，添加一个外围类的引用参数。

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;

/**
* This program demonstrates the use of inner classes.
* @version 1.10 2004-02-27
* @author Cay Horstmann
*/
public class InnerClassTest
{
public static void main(String[] args)
{
TalkingClock clock = new TalkingClock(1000, true);
clock.start();

// keep program running until user selects "Ok"
JOptionPane.showMessageDialog(null, "Quit program?");
System.exit(0);
}
}

/**
* A clock that prints the time in regular intervals.
*/
class TalkingClock
{
/**
* Constructs a talking clock
* @param interval the interval between messages (in milliseconds)
* @param beep true if the clock should beep
*/
public TalkingClock(int interval, boolean beep)
{
this.interval = interval;
this.beep = beep;
}

/**
* Starts the clock.
*/
public void start()
{
ActionListener listener = new TimePrinter();
Timer t = new Timer(interval, listener);
t.start();
}

private int interval;
private boolean beep;

public class TimePrinter implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
Date now = new Date();
System.out.println("At the tone, the time is " + now);
if (beep) Toolkit.getDefaultToolkit().beep();
}
}
}

6. 只有内部类可以是私有的，而常规类只可以具有包可见性或公有可见性。

7. 局部内部类：如果内部类只在某个方法中使用了一次，就可以在方法中定义一个局部内部类。局部内部类不能用public或private访问说明符进行申明。它的作用域被限定在申明这个局部类的块中。局部类不仅可以访问外部类，还可以访问局部变量，不过这些局部变量必须被申明为final。

8. 匿名内部类：如果只创建局部内部类的一 个对象，就不用命名了。这种类被称为匿名内部类，如GUI编程中的监听器类对象。

9. 静态内部类：有时候使用内部类只是为了把一个类隐藏在另一个类的内部，并不需要内部类引用外部类的对象，为此，可以将内部类申明为static，以便取消产生的引用。只有内部类可以声明为static，声明在接口中的内部类自动成为static和public。

/**
* This program demonstrates the use of static inner classes.
* @version 1.01 2004-02-27
* @author Cay Horstmann
*/
public class StaticInnerClassTest
{
public static void main(String[] args)
{
double[] d = new double[20];
for (int i = 0; i < d.length; i++)
d[i] = 100 * Math.random();
ArrayAlg.Pair p = ArrayAlg.minmax(d);
System.out.println("min = " + p.getFirst());
System.out.println("max = " + p.getSecond());
}
}

class ArrayAlg
{
/**
* A pair of floating-point numbers
*/
public static class Pair
{
/**
* Constructs a pair from two floating-point numbers
* @param f the first number
* @param s the second number
*/
public Pair(double f, double s)
{
first = f;
second = s;
}

/**
* Returns the first number of the pair
* @return the first number
*/
public double getFirst()
{
return first;
}

/**
* Returns the second number of the pair
* @return the second number
*/
public double getSecond()
{
return second;
}

private double first;
private double second;
}

/**
* Computes both the minimum and the maximum of an array
* @param values an array of floating-point numbers
* @return a pair whose first element is the minimum and whose second element
* is the maximum
*/
public static Pair minmax(double[] values)
{
double min = Double.MAX_VALUE;
double max = Double.MIN_VALUE;
for (double v : values)
{
if (min > v) min = v;
if (max < v) max = v;
}
return new Pair(min, max);
}
}