Java学习笔记2-3

Java学习笔记2-3
阅读书籍:Java基础入门教程.pdf
章    节:第6-9章(共12章)
时    间:2014年5月1日张永辉
================================================================================
第六章类的继承
    6.1 继承的基本概念
        1 类的继承格式
        class  父类                 //定义父类
        {
        }
        class  子类 extends 父类    //用 extends 关键字实现类的继承
        {                           //不能多重继承, 即A同时继承B,C
        }                           //可以多层继承，即A继承B, B继承C

        eg  class Person
            {
                int age;
                String name;
                public Person()
                {}
                public Person(String name,int age)
                {
                    this.name = name;
                    this.age = age;
                    System.out.println("1 String name,int age");
                }
                //private 属性 不能被子类显示访问
                private String addr;
                public void setAddr(String addr) //但能通过此方法访问
                {
                    this.addr = addr;
                }
                public String talk()
                {
                    return this.name + " 今年  " + this.age + "岁";
                }
            }
            class stdu  extends Person
            {
                String school;
                public stdu()       //会先调用父类的构造函数，后调用子类的
                {
                    //super();              此句是隐藏了的，是默认调用父类的构造方法。只能放在程序的第一行
                    //super("张三",29);     怎样写就调用了 父类的重载构造方法。
                    //super.age = 23;       也可以调用父类的属性
                    System.out.println("2 stdu");
                }

                public stdu(String address)
                {
                    //对父类private 属性的访问
                    setAddr(address);
                }
                //复写了父类的方法  子类复写的方法不能拥有比父类中更严格的访问权限
                public String talk()
                {
                    //使用super.可以访问父类方法
                    return super.talk() + this.name + " 今年真的  " + this.age + "岁";
                }
            }
        调用：
            stdu me = new stdu();
            me.name = "zyhui";
            me.age = 20;
            System.out.println(me.name + " is " + me.age);
            System.out.println(me.talk());
        对比：
            this
                1、表示当前对象
                2、调用本类中的方法或属性
                3、调用本类中的构造方法时，放在程序首行
            super
                1、子类调用父类的方法或属性
                2、调用父类中构造方法时，放在程序首行
            所以 super 与 this 调用构造方法的操作是不能同时出现的

    5.2 抽象类
        1 抽象类的定义格式
            abstract class  类名称      //定义抽象类
            {
                数据成员
                方法()
                {   定义一般方法
                } tgy
                abstract  方法()
            }
            eg
                //含有抽象方法的类必须用abstract修饰成抽象类，
                //抽象类 不能实例化，其子类必须复写所有抽象方法，否则还是抽象类。
                abstract class Person
                {
                    String name;
                    int age;
                    public Person(String name)
                    {
                        this.name = name;
                    }
                    //声明抽象类方法 ，不需实现
                    public abstract String talk();
                }
                class stdu  extends Person
                {
                    public stdu(String name)
                    {
                        //必须明确调用抽象类中的构造方法
                        super(name);
                    }
                    //必须复写抽象类方法
                    public  String talk()
                    {
                        return this.name + " age is " + age;
                    }
                }
    6.3 Object 类
        1 Object类，它是所有类的父类， 当没有指定父类时默认是 class Person extends Object{}
        2 Object类有一个toString()方法，所以任何类都可调用此方法。 也可以复写此方法。
    6.4 final 关键字
        1、  final 标记的类不能被继承。      如：final class Person{}
        2、  final 标记的方法不能被子类复写。如： final public String talk(){}
        3、  final 标记的变量（成员变量或局部变量）即为常量，只能赋值一次。 如：final int i = 10 ; i++ 编译错误
    6.5 接口
        1 接口的定义格式
            interface  接口名称                                    //定义抽象类
            {
                final  数据类型  成员名称  =  常量  ；             //必须赋初值,且不能更改        [此处final可以省略]
                abstract  返回值的数据类型  方法名称（参数…）;     //在抽象方法里，必须是抽象方法 [此处abstract可以省略]
            }
            //abstract
        2 接口的实现
            class 类名称 implements 接口 A,接口 B                   // 接口的实现
            { ... }
        3 接口的扩展
            interface  子接口名称  extends  父接口 1，父接口 2 ...
            { ... }

        eg  //【定义2个接口】
            interface  Person
            {
                final String name_i = "zyhui";  //属性必须赋初值,且不能更改        [此处final可以省略]
                final int age_i = 20;
                public abstract String talk();  //所有方法都必须是抽象类方法  [所以此处abstract可以省略]
            }
            interface  dog
            {
                final String dname = "dog";
                public abstract String dogtalk();
            }
            //【 接口的继承/扩展 】 可以继承多个
            interface  my  extends Person,dog
            {
            }
            //【 接口的实现 】即创造新的类，但 接口不能用来创建对象
            class stdu implements Person ,dog
            {
                String name;
                public stdu(String name)
          {
                    this.name = name;
                }
                //必须实现接口中的所有方法
                public String talk()
                {
                    return this.name + " age is " + age_i;
                }
                public String dogtalk()
                {
                    return  " dog is    " + dog.dname;
                }
            }
    6.6 对象多态
        1 函数重载是一种多态
        2 对象的多态性
            eg  class fa
                {
                    String name;
                    void fun1(){System.out.println("fa-fun1");};
                    void fun2(){System.out.println("fa-fun2");};
                }
                class sun extends fa
                {
                    //实例化对象由子类实现的,所以父类的fun1()被复写了
                    void fun1(){System.out.println("sun-fun1");};
                    void fun3(){System.out.println("sun-fun3");};
                    //[复写父类（Object 类）中的 equals 方法]
                    public boolean equals(Object objt)
                    {
                        fa fa_a = this;
                        if(objt instanceof fa)              //前提判断
                        {
                            fa fa_b = (fa)objt;             //强制转换
                            if(fa_a.name == fa_b.name)      //2个进行比较
                            {
                                return true;
                            }
                        }
                        return false;
                    }
                }
            调用：
                //向上转型：父类对象由子类实例化 ，会丢失精度,自动完成
                fa fa1 = new sun(); //若此句写为：fa fa1 = new fa()， 则向下转型会运行错误
                fa1.fun1();         //输出：sun-fun1
                fa1.fun2();         //输出：fa-fun2
                //向下转型：需要强制转换
                sun s1 = (sun)fa1;
                s1.fun1();          //输出：sun-fun1
                s1.fun2();          //输出：fa-fun2
                //[instanceof 关键字]
                if(fa1 instanceof sun){}  //返回真

        3 instanceof 关键字
            用途：判断一个类是否实现了某个接口，也可以用它来判断一个实例对象是否属于一个类
            语法：对象instanceof 类(或接口)
                eg if(fa1 instanceof sun){}
        4 复写 Object 类中的 equals 方法
            见上面的实例。
        5 接口对象的实例化
            eg  interface Usb                   //声明一 Usb接口
                {
                    public void start() ;
                    public void stop() ;
                }
                //接口的实现： [关键字：implements]
                class MoveDisk implements Usb   //声明 MoveDisk 类,并复写2个方法
                {
                    public void start()
                    {   System.out.println("MoveDisk start...");}
                    public void stop()
                    {   System.out.println("MoveDisk stop...");}
                }
                class Mp3 implements Usb        //声明 MP3类,并复写2个方法
                {
                    public void start()
                    {   System.out.println("MP3 start...");}
                    public void stop()
                    {   System.out.println("MP3 stop...");}
                }
                class Computer
                {
                    public void work(Usb u)
                    {
                        u.start() ;
                        u.stop() ;
                    }
                }
            调用：
                new Computer().work(new MoveDisk()) ;
                new Computer().work(new Mp3()) ;
    6.7 匿名内部类(略)
第七章   异常处理
    7.1 异常的基本概念
        1 几种常见的异常
            1、 算术异常（ArithmeticException）。
            2、 没有给对象开辟内存空间时会出现空指针异常
            3、 找不到文件异常（FileNotFoundException）。
            若无处理异常的程序代码，则默认先抛出异常、然后停止程序运行。
        2 异常处理的语法 及 架构
            try
            {
                要检查的程序语句
            }
            catch(异常类  对象名称)     //有异常，且异常类型相同才会执行此块
            {
                异常发生时的处理语句
            }
            finally                     //可以省略此块
            {
                一定会运行到的程序代码
            }
    7.2 异常类的继承架构
            Throwable
            /       \
        Error       Exception       :Error是严重错误， Exception是一般异常
                    |       \
                IOException RuntimeException        : IOException必须要编写异常处理代码,Runtime可以不用
                            /               \
                        ArithmethicException IndexOutObBoundsException
                                                /               \
                        StringIndexOutOfBoundsException     ArrayIndexOutOfException
    7.3 抛出异常
        语法:  throw 异常类实例对象;
        1 在程序中跑出异常
            eg  try
                {
                    if(i == 0)
                    {   //抛出实例对象，所以要用new
                        throw new ArithmeticException("不能为0");
                    }

                }catch(ArithmeticException e)
                {
                    System.out.println("异常：" + e);
                }
            输出： 异常：java.lang.ArithmeticException: 不能为0
        2 指定方法抛出异常
            格式： 方法名称(参数) throws 异常类1 , 异常类 2 , ...
            eg  class Test
                {
                    int add(int a,int b) throws Exception   //此方法中不处理异常,在调用此方法的地方处理
                    {
                        return a/b;
                    }
                }
            调用
                Test t = new Test();
                try
                {
                    t.add(1,0);
                }catch(Exception e)     //必须在此处理异常,否则编译不通过
                {}
        3 编写异常类
            语法：
                class 异常名称 extends Exception    //异常必须继承Exception类
                {   ...                             //可以在此编写异常处理事件
                }
            eg
                class DefaultException extends Exception
                {
                    private static final long serialVersionUID = 1L;    //有此句不会报告警
                    public DefaultException(String msg)
                    {
                        super(msg);     //调用Exception类的构造方法,存入异常信息
                    }
                }
            使用：
                throw new DefaultException("自定义异常!") ;

第八章  包及访问权限
    8.1 包的概念及使用
        1 package
            声明格式：package package 名称
            用    途：避免名称重复而采用的一种措施
            eg 在Hello.java的内容如下：
                package demo.java;              //相当于将Person、Hello类放入了demo\java\文件夹之下
                public class Hello
                {
                    public static void main(String args[])
                    {   System.out.println(new Person().talk()) ;   }
                }
                class Person
                {
                    public String talk()
                    {   return "Class-Person";          }
                }
            在命令行编译:
                javac -d . Hello.java
                生成2个文件
                    .\demo\java\Hello.class
                    .\demo\java\Person.class
            在命令行执行：
                java demo.java.Hello
        2 import 语句的使用：package的导入
            声明格式 import package 名称.类名称
            eg
                Hello.java的内容如下：
                    package demo.java.b;
                    import  demo.java.a.Persion;
                    public class Hello              //必须是public外部才能访问
                    {
                        public static void main(String args[])
                        {
                            System.out.println(new Persion().talk());
                            //不用import，可以这样写： new demo.java.a.Persion.talk()
                        }
                    }
                Persion.java的内容如下：
                    package demo.java.a;
                    public class Persion            //必须是public外部才能访问
                    {
                        public String talk()
                        {
                            return "Class-Person";
                        }
                    }
            编译Persion：
                javac -d . Persion.java             //生成文件 .\demo\java\a\Persion.class
            编译Hello.java
                javac -d . Hello.java               //生成文件 .\demo\java\b\Hello.class
            运行
                java demo.java.a.Hello              //OK
        3 JDK常用的包
            java.lang       核心类，如 String、Math、Integer、System和 Thread，提供常用功能。(java1.2 以后的版本自动包含此包)
            java.lang.reflect 用于实现 java 类的反射机制。
            java.awt        构成抽象窗口工具集（abstract window toolkits），用来构建和管理应用程序的图形用户界面(GUI)。
            javax.swing     建立图形用户界面，相对于java.awt而言是轻量级组件。
            java.applet     applet运行所需的一些类。
            java.net        执行与网络相关的操作的类。
            java.io         提供多种输入/输出功能的类。
            java.util       实用工具类，如定义系统特性、与日期日历相关的函数。
        4 命名习惯
            包名        ：一律小写.                 如：demo.java
            类\接口名   :用名词，首字母大写，       如：TestPerson
            方法名      :第一个单词小写+首字母大写. 如：talkMySelf
            常量名      :每个字母一律大写.          如：COUNTRY
    8.2 类成员的访问控制权限
                       private    default     protected    public
        同一类          Y           Y           Y           Y
        同一包中的类    .           Y           Y           Y
        子类            .           .           Y           Y
        其他包中的类    .           .           .           Y
    8.3 jar包。
        使用 jar命令可以将一个包打成一个 jar文件，供用户使用