Java基础7-异常;jar包

昨日内容回顾

1. 多态：多种状态，多态的前提条件是继承或者是实现

2. 面向接口编程

   • 降低耦合度
   • 接口是最低标准，接口可以多重继承
   • 接口中的所有方法都是抽象方法
   • 抽象类中可以没有抽象方法

3. 匿名内部类对象

   将对类的继承，方法重写，对象的创建集成到一行代码中区。

作业解析

1. 使用接口进行如下程序设计
   
   个人电脑(PC)具有PCI插槽，可以插入PCI卡。显卡、声卡、语音卡都可以作为PCI卡插入PCI插槽中
   
   PC,PCI,slot,VideoCard,SoundCard, VoiceCard

    interface PCI{
        public void pci();
    }
   
    class VideoCard implements PCI{
        public void pci(){
            System.out.println("This is a videoCard");
        }
    }
   
    class SoundCard implements PCI{
        public void pci(){
            System.out.println("This is a soundCard");
    }
   
    class VoiceCard implements PCI{
        public void pci(){
            System.out.println("This is a voiceCard");
    }
   
    class PC{
        public void slot(PCI pci){
            pci.pci();
        }
    }
   
    class PCIDemo{
        public static void main(String[] args){
            PC pc = new PC();
            pc.slot(new VideoCard());
            pc.slot(new SoundCard());
            pc.slot(new VoiceCard());
        }
    }
   

2. 高富帅
   
   Height
   
   Rich
   
   Handsome
   
   Girl boyFriend(HRH h)
   
   用匿名内部类实现

    interface Height{
        public void high();
    }
   
    interface Rich{
        public void rich();
    }
   
    interface Handsome{
        public void handsome();
    }
   
    interface HRH extends Height,Rich,Handsome{
    }
   
    class Girl{
        public void boyFriend(HRH h){
            h.high();
            h.rich();
            h.handsome();
        }
    }
   
    class NoNameDemo{
        public static void main(String[] args){
            Girl girl = new Girl();
            girl.boyFriend(new HRH(){
                public void high(){
                    System.out.println("很高");
                }
                public void handsome(){
                    System.out.println(“很帅”);
                }
                public void rich(){
                    System.out.println(“很有钱”);
                }
            });
        }
    }
   

3. 使用适配器模式实现窗口的事件处理程序
   
   窗口可以响应最大化事件、最小化事件、大小改变事件、恢复事件、移动事件、关闭事件
   
   通过适配器对大小改变事件、移动事件和关闭进行默认处理，窗口只关心最大化和最小化事件即可。
   
   Window
   
   WindowListener{max min resize restore move close}

    interface WindowListener{
        public void max();
        public void min();
        public void resize();
        public void restore();
        public void move();
        public void close();
    }
   
    abstract class WindowListenerAdapter implements WindowListener{
        public void resize(){
        }
        public void restore(){
        }
        public void move(){
        }
        public void close(){
        }
    }
   
    class Window{
        WindowListener listener;
        public void setListener(WindowListener listener){
            this.listener = listener;
        }
   
        public void max(){
            listener.max();
        }
   
        public void min(){
            listener.min();
        }
    }
   
    class AdapterDemo(){
        public static void main(String[] args){
            Window window = new Window();
            window.setListener(new WindowListenerAdapter(){
                public void max(){
                    System.out.println("窗口最大化");
                }
                public void max(){
                    System.out.println("窗口最小化");
                }
            });
            window.max();
            window.min();
        }
    }
   

4. 使用抽象类和接口实现适配器模式设计。涉及的类和接口分别为ButtonListener(接口),
   
   其中含有click() / dbclick() / keyUp() / keyDown()等方法。
   
   ButtonAdapter(按钮适配器类)，适配器中对非click()方法进行默认实现。
   
   Button类中添加addListener(ButtonListener l)方法。

    interface ButtonListener{
        public void click();
        public void dbclick();
        public void keyUp();
        public void keyDown();
    }
   
    abstract class ButtonAdapter implements ButtonListener {
        public void keyUp(){
        }
        public void keyDown(){
        }
    }
   
    class Button{
        private ButtonListener l;
        public void addListener(ButtonListener l){
            this.l = l;
        }
        public void click(){
            l.click();
        }
        public void dbclick(){
            l.dbclick();
        }
    }
   
    class AdapterDemo(){
        public static void main(String[] args){
            Button button = new Button();
            Button.addListener(new ButtonAdapter(){
                public void click(){
                    System.out.println("单击了按钮");
                }
                public void dbclick(){
                    System.out.println("双击了按钮");
                }
            });
            button.click();
            button.dbclick();
        }
    }
   

5. 阐述什么是多态。
   
   为什么函数可以覆盖，而属性不能覆盖？
   
   答：对象的多种状态，对继承来说，用父类引用子类的对象；对接口来说，用接口引用实现类的对象。根据javabean原则，公有方法可以被继承，因此可以被子类覆盖，而属性是私有财产，不能被子类覆盖。

异常

1. Throwable 的两个子类Exception 和 Error

    java.lang.Object
    |
    |---java.lang.Throwable
        |
        |---java.lang.Error
        |---java.lang.Exception
   

2. 使用throw关键字抛出异常对象：throw new XxxException(...);

3. throws关键字用于声明方法抛出了异常
   
   public void function(...) throws XxxException,YyyException{
   
   ...
   
   }

4. Exception的处理方式

   • try-catch-finally

       try{
           ...
       }
       catch(Throwable e){
       }
       finally{
       }
     

     可以有多个catch语句，catch的顺序需要注意，子类异常需要先行catch，否则代码不可达，编译也无法通过。

   • 在方法上给出抛出异常的声明

5. RuntimeException在方法定义时可以不进行抛出声明，也不使用try-catch-finally 进行捕获

6. 方法覆盖时，不可以追加新的异常抛出声明，但是可以抛出所覆盖的方法声明的异常的子类

package

1. 包，类似于文件夹，组织管理类的结构
   
   www.sina.com
   
   www.baidu.com
   
   com.sina.weibo

2. 完整类名：包名 + . + 类名， 比如com.xkzhai.java.PackageDemo
   
   路径：com\xkzhai\java\PackageDemo.class

3. 编译含有包名的类

    javac -d classes xxx.java //-d指定存放类文件的位置，同时生成对应的文件夹目录树
    javac -cp classes;classes2; -d . xxx.java // -cp 指定贬编译程序时需要搜索的类的类路径顺序
   

4. 运行含有包名的类
   
   运行java程序，需要指定类的完整类名

    java -cp classes com.xkzhai.java.PackageDemo
   

5. 引入包中的类，使用import关键字

6. 含有包名的类，需要使用public 修饰，否则无法在其他包中访问

dos命令

1. tree /F //输出目录树
2. rmdir /S/Q //递归删除文件夹，不提示

权限修饰符

1. public

2. protected

3. default

4. private

	public	protected	default	private
同类	v	v	v	v
同包	v	v	v
子类	v	v
不同包	v

jar

1. jar: java archiver, java归档文件
   
   打包java库文件

2. 对java的类文件进行归档

    //将foo目录下的所有文件进行归档，生成xxx.jar
    jar cvf xxx.jar -C foo/ .
    //归档时，指定入口点，会在清单文件中添加Mai-Class属性
    jar cvfe xxx.jar a.a1.a11.a111.A -C foo/ . //e指定入口点
   

3. 通过jar文件执行程序

    java -cp xxx.jar a.a1.a11.a111.A
    java -cp xxx.jar;classes;...;. a.a1.a11.a111.A
    //使用java -jar参数来运行程序
    java -jar xxx.jar //需要在归档时指定入口点
   

作业

1. 利用白富美接口案例，土豪征婚使用匿名内部类对象实现。

2. 定义三角形类Trianle,里面包含三个int类型属性，分别表示三条边的长度，
   
   构造三角形对象时，任意两边之和是否大于第三边，如若不成立，抛出自定义异常。

3. Person类中增加birthday属性，对setBirthday(int ,int , int )方法进行异常处理，
   
   要求年有效、月有效、日有效、年月日指定的具体日期有效，对不同情况分别抛出不同的异常。
   
   year:>1970, month:1-12, day:1-31

4. 将类定义到指定的包下。com.xkzhai,编译之后，打成jar文件。

5. 相互之间使用jar包，放置cp下，对class进行重用。

6. 设计程序，考查修饰符。public -> protected -> default -> private(选做题)

7. 编写ArrayTool，把冒泡排序，选择排序，二分法查找，空心三角形等打成jar包。

8. 预习多线程。