11月4号学习(第2天)

计划
7到12章的复习
7.复用类
8.多态
9.接口
10.内部类
11.持有对象
12.通过异常处理错误

复习结果

复用类
1：类的复用有三种形式  1组合——>即把对象的引用置于新类中

初始化引用的4中方式  1定义对象时初始化（那么其在构造函数调用前已经被初始化）。
                     2在类的构造体中初始化
                     3实例初始化
                     4就是在使用对象前完成初始化——惰性初始化
//包名
package javafuxi2;

/**
* WatreSource()类
* @author xinjie
*
*/
class WatreSource{

//定义私有参数
private String s;

/**
* 构造方法
*/
WatreSource(){

//输出
System.out.println("WatreSource()");

//定义参数
s = "Constructed";

}

/**
* toString()方法
*/
public String toString(){

//返回到s
return s;

    }
}
/**
* SprinnklerSystem()类
* @author xinjie
*
*/
public class SprinklerSystem{

//定义私有参数
private String valve1, valve2, valve3, valve4;

//定义私有参数
private WatreSource source = new WatreSource();

//定义私有参数
private int i;

//定义私有参数
private float f;

/**
* toString()方法
*/
public String toString(){

//返回
return

"valve1 = " + valve1 + " " +
"valve2 = " + valve2 + " " +
"valve3 = " + valve3 + " " +
"valve4 = " + valve4 + "\n" +
"i = " + i + " " + "f = " + f + " " + "source = " + source;

}
/**
* main()方法
* @paramString[] args
* return 空
*/
public static void main(String[] args){

//创建实例化对象
SprinklerSystem sprinklers = new SprinklerSystem();

//输出
System.out.println(sprinklers);
}
}

2继承   ——>按照现有类的类型创造新类。采用现有类的形式并在其中添加新代码。
             1创建一个新类， 除非已明确指出从其他类中继承，否则就是在隐式地从 java的标准根类Object进行继承
             2关于继承的构造函数的问题，首先构造函数的不能被继承的。从语法上来说，构造函数要与类名同名，若
              子类继承父类的构造函数那么语法就出错了。
              我们在创建子类对象的时候会自动调用父类的构造函数，注意这里的（调用）不是（继承）调用有两种方
          式（继承）和（组合）。
            3 其次子类/父类的构造函数的关系——>即若子类无现式（super()）调用父类的有参构造函数，那么必调用父类的无参构造函数。
            4方法重写的问题 1重写方法必须和被重写方法具有相同的参数列表，返回类型必须和被重写方法的返回类型相同或者是返回类型的子类型
                             2重写方法的访问控制修饰符不能比被重写方法更严格（比如一个在父类中声明为public的方法重写成一个protected的方法）
                             3重写方法不能抛出新的检查异常，或者是抛出比被重写方法声明的检查异常更广泛的检查异常
                             4只有实例方法才能被重写，超类中的final方法不能被重写
//包名
package javafuxi2;
/**
* Cleanser()类
* @author xinjie
*
*/
class Cleanser {

//定义私有参数
private String s = "Cleanser";

/**
* append()方法
* @param String a
* 返回值为空
*/
public void append(String a){

//s=s+a
s += a;
}

/**
* dilute()方法
* 返回值为空
*/
public void dilute() {

//赋值
append(" dilute()");
}

/**
* apply()方法
* 返回值为空
*/
public void apply(){

//赋值
append(" apply()");
}

/**
* scrub()方法
* 返回值为空
*/
public void scrub(){

//赋值
append("scrub()");
}

/**
* toString()方法
* 返回s
*/
public String toString(){

return s;
}

    /**
     * mian()方法
     * @paramString[] args
     * 返回值为空
     */
public static void main(String[] args){

//创建实例化对象
Cleanser x = new Cleanser();

//调用方法
x.dilute();x.apply();x.scrub();
}
}

/**
* Detergent()类
* @author xinjie
* extends 继承 Cleanser
*/
public class Detergent extends Cleanser{

    /**
     * scrub()方法
     * 返回值为空
     */
public void scrub(){

append(" Detergent.scrub");

//调用方法
super.scrub();
}

    /**
     * foam()方法
     * 返回值为空
     */
public void foam(){

//赋值
append(" foam()");
}

    /**
     * main()方法
     * @param String[] args
     * 返回值为空
     */
public static void main(String[] args){

//创建实例化对象
Detergent x = new Detergent();

//调用方法
x.dilute();

//调用方法
x.apply();

//调用方法
x.scrub();

//调用方法
x.foam();

//输出
System.out.println("Testing base class:");

//调用方法
Cleanser.main(args);
}
}


3代理——java 没有对其提供明确的支持，所以不再阐述。


多态
面向对象的一种技术
里面包含有 继承（extends） 覆盖（override） 重载（overloading） 向上转型（重写父类的方法）（）
父类的对象指向子类的引用
//包名
package javafuxi2;

/**
* Son1类
* @author xinjie
* 继承 Father
*/
public class Son1 extends Father{

//重写方法
/**
* hitChild()方法
* 返回值为空
*/
public void hitChild(){
  
   //输出  
   System.out.println("为什么打我？我做错什么了！");
}
}
/**
* Son2()类
* @author xinjie
* 继承 Father
*/
public class Son2 extends Father{

//重写方法
/**
* hitChild()方法
* 返回值为空
*/
public void hitChild(){

   //输出  
   System.out.println("我知道错了，别打了！");
}
}
/**
* Son3类
* @author xinjie
* 继承 Father
*/
public class Son3 extends Father{

//重写方法
/**
* hitChild()方法
* 返回值为空
*/
public void hitChild(){

   //输出
   System.out.println("我跑，你打不着！");
}
}
/**
* Test类
* @author xinjie
*
*/
public class Test{

/**
* main()方法  
* @paramString[] args
* 返回值为空
*/
public static void main(String args[]){

  //引用
      Father father;
         
      //创建实例化对象
      father = new Son1();
     
      //调用方法
      father.hitChild();
         
      //创建实例化对象
      father = new Son2();
     
      //调用方法
      father.hitChild();
         
      //创建实例化对象
      father = new Son3();
     
      //调用方法
      father.hitChild();
   }
}

接口的特性
1.接口中的方法可以有参数列表和返回类型，但不能有任何方法体。
2.接口中可以包含字段，但是会被隐式的声明为 static 和 final 。
3.接口中的字段只是被存储在该接口的静态存储区域内，而不属于该接口。
4.接口中的方法可以被声明为 public 或不声明，但结果都会按照 public 类型处理。
5.当实现一个接口时，需要将被定义的方法声明为 public 类型的，否则为默认访问类型，              Java 编译器不允许这种情况。
6.如果没有实现接口中所有方法，那么创建的仍然是一个接口。
7.扩展一个接口来生成新的接口应使用关键字 extends ，实现一个接口使用 implements 。
8 接口中的方法是抽象方法(abstract)，不能是静态方法(static).接口的所有方法都是抽象的，而抽象方法是没有static，有static的方法是不能override的，所以这样定义接口才有意义。
接口的作用
接口是用来标记类的，不同的类属于不同的接口（通过向上转类型）管理接口比管理各种各样的类方便多了，接口是抽象类的观点

//调用包
import java.util.*;

//接口Instrument5
interface Instrument5 {

    //赋值
    int i = 5;
   
    /**
     * play()方法
     * 返回值为空
     */
    void play();
   
    //赋值
    String what();
   
    /**
     * adjust()方法
     * 返回值为空
     */
    void adjust();
}

/**
* Wind5()类
* @author xinjie
* 实现多个接口
*/
class Wind5 implements Instrument5 {

/**
* play()方法
*/
    public void play() {
   
    //输出
        System.out.println("Wind5.play()");
    }
   
    /**
     * what()方法
     * 返回值为Wind5
     */
    public String what() { return "Wind5"; }
   
    /**
     * adjust()方法
     */
    public void adjust() {}
}

/**
* Percussion5()类
* @author xinjie
* 实现多个接口
*/
class Percussion5 implements Instrument5 {

/**
* play()方法
*/
    public void play() {
 
      //输出
      System.out.println("Percussion5.play()");
   
    }
   
    /**
     * what()方法
     * 返回值为Percussion5
     */
    public String what() { return "Percussion5"; }
   
/**
* adjust()
* 返回值为空
*/
    public void adjust() {}
}

/**
* Stringed5()类
* @author xinjie
* 实现多个接口
*/
class Stringed5 implements Instrument5 {

/**
* play()
* 返回值为空
*/
    public void play() {
 
      //输出
      System.out.println("Stringed5.play()");
   
    }
   
    /**
     * what()方法
     * 返回值为Stringed5
     */
    public String what() { return "Stringed5"; }
   
/**
* adjust()
* 返回值为空
*/
    public void adjust() {}
 
}

/**
* Brass5()类
* @author xinjie
* 实现多个接口
*/
class Brass5 extends Wind5 {

/**
* play()方法
* 返回值为空
*/
    public void play() {
 
      //输出
      System.out.println("Brass5.play()");
   
    }
   
/**
* adjust()方法
* 返回值为空
*/
    public void adjust() {
 
      //输出
      System.out.println("Brass5.adjust()");
   
    }
}

/**
* Woodwind5()类
* @author xinjie
* 实现多个接口
*/
class Woodwind5 extends Wind5 {

/**
* play()方法
* 返回值为空
*/
    public void play() {
 
      //输出
      System.out.println("Woodwind5.play()");
   
    }
   
/**
* what()方法
* 返回值为Woodwind5
*/
    public String what() { return "Woodwind5"; }
 
}

/**
* Music5()类
* @author xinjie
*
*/
public class Music5 {
   
    /**
     * tune()方法
     * @param Instrument5 i
     * 返回值为空
     */
    static void tune(Instrument5 i) {
     
      //调用方法
      i.play();
    }
   
    /**
     * tuneAll()方法
     * @param Instrument5 e
     * 返回值为空
     */
    static void tuneAll(Instrument5[] e) {
 
      //for循环
      for(int i = 0; i < e.length; i++)
   
    //赋值
        tune(e[i]);
    }
   
    /**
     * main()方法
     * @param String[] args
     * 返回值为空
     */
    public static void main(String[] args) {
 
      //创建实例化对象
      Instrument5[] orchestra = new Instrument5[5];
     
      //赋值
      int i = 0;
     
      //创建实例化对象
      orchestra[i++] = new Wind5();
     
      //创建实例化对象
      orchestra[i++] = new Percussion5();
     
      //创建实例化对象
      orchestra[i++] = new Stringed5();
     
      //创建实例化对象
      orchestra[i++] = new Brass5();
     
      //创建实例化对象
      orchestra[i++] = new Woodwind5();
     
      //赋值
      tuneAll(orchestra);
    }
}

内部类的特性

1)只能在包含类中直接使用内部类名，在包含类的外面，应该使用限定名来引用内部类。内部类不能与包含类同名。
2)内部类可以定义在方法体中，此时该方法中的本地变量和形参都不能被内部类中的方法访问，除非这些变量是final常量。
3)内部类可以使用包含类的静态成员变量，实例变量（即非静态成员变量），以及包含块的final型本地变量。
4)内部类可以定义为abstract。
5)内部类可以声明为任意的访问保护权限，即内部类有四个权限。
6)内部类能作为接口被其它内部类实现。
7)内部类声明为static后，自动成为顶级类。静态内部类无需外部类的实例就可直接引用。静态内部类中的方法不能访问外部类的非静态成员。
8)内部类中不能声明任何静态成员，只有顶级类中才能声明静态成员。

package javafuxi2;

//调用包
import java.awt.*;

//调用包
import java.awt.event.*;

//调用包
import java.util.*;

//调用包
import javax.swing.*;

//调用包
import javax.swing.Timer;

/**
* InnerClassTest 类
* @author xinjie
*
*/
public class InnerClassTest {

/**
* main()方法
* @param String[] args
* 返回值为空
*/
    public static void main(String[] args){
   
    //创建实例化对象
        TalkingClock clock = new TalkingClock(1000,true);
        
        //调用方法
        clock.start();
       
        //调用方法
        JOptionPane.showConfirmDialog(null, "Quti program?");
       
        //调用方法
        System.exit(0);
    }

}

/**
* TalkingClonk 类
* @author xinjie
*
*/
class TalkingClock{

/**
* TalkingClock()构造方法
* @param int interval boolean beep
*/
    public TalkingClock(int interval,boolean beep){
   
    //调用方法
        this.interval = interval;
       
        //调用方法
        this.beep = beep;
    }
   
    /**
     * start()方法
     * 返回值为空
     */
    public void start(){
   
    //创建实例化
        ActionListener listener = new TimerPrinter();
       
        //创建实例化
        Timer t = new Timer(interval,listener);
       
        //调用方法
        t.start();
    }
   
    //私有的int类interval
    private int interval;
   
    //私有的boolean类beep
    private boolean beep;
   
    /**
     * TimerPrinter 类
     * @author xinjie
     * 接口 ActionListener
     */
    public class TimerPrinter implements ActionListener {
   
    /**
    * actionPerformed()方法
    * @param ActionEvent event
    * 返回值为空
    */
        public void actionPerformed(ActionEvent event){
       
        //创建实例化对象
            Date now = new Date();
           
            //输出
            System.out.println("At the tone,the time is"+now);
           
            //调用方法
            Toolkit.getDefaultToolkit().beep();
        }

    }
}

持有对象的概念

Collection 一个独立元素的序列

//包名
package javafuxi2;

//调用包
import java.util.*;

/**
* SimleCollection 类
* @author xinjie
*
*/
public class SimleCollection {

/**
* main()方法
* @param String[] args
* 返回值为空
*/
public static void main(String[] args){

//创建实例化对象
Collection<Integer> c = new ArrayList<Integer>();

//for语句
for(int i = 0; i < 10; i++)

//调用方法
c.add(i);

//for语句
for(Integer i : c)

//输出
System.out.println(i + ", ");
}

}

通过异常处理错误

异常的捕获 定义异常

//包名
package javafuxi2;

//调用包
import java.util.logging.*;

//调用包
import java.io.*;

/**
* LoggingException 类
* @author xinjie
* 继承 Exception
*/
class LoggingException extends Exception{

//私有Logger引用Logger的调用方法
private static Logger logger = Logger.getLogger("LoggingException");


/*
* LoggingException()方法
*/
public LoggingException(){


//创建实例化对象
StringWriter trace = new StringWriter();

//创建实例化对象
printStackTrace(new PrintWriter(trace));

//调用方法
logger.severe(trace.toString());
}
}

/**
* LoggingExceptions 类
* @author xinjie
*
*/
public class LoggingExceptions{

/**
* main()方法
* @param String[] args
* 返回值为空
*/
public static void main(String[] args){

//如果有异常
try{

//创建实例化对象
throw new LoggingException();

//在地理捕捉
} catch(LoggingException e){


//输出
System.out.println("Caugth " + e);
}
}
}



今天的单词
void main String