[零基础学JAVA]JavaSE面向对象部分-15.面向对象高级.doc

上季内容回顾：
1、super与this关键字
2、方法的重载与覆写
本季主要知识点：
1、final关键字
2、简单了解一下抽象类与接口(是JAVA中最重要的部分)
final关键字

终结器 —— final
1、被final标记的类不能被继承
final class A    
{    
};    
class B extends A    
{    
};
验证一下：

2、被final标记的方法不能被子类覆写
final class A    
{    
        public final void print(){}    
};    
class B extends A    
{    
        public void print(){}    
};

3、被final标记的变量就成为常量，如果成为常量，则以后不能修改
class A    
{    
        final String NAME = "Hello";    
        public final void print()    
        {    
                NAME = "World";    
        }        
};

之前在声明变量的时候是第一个单词的首字母小写，之后每个单词的首字母大写。如果使用final声明常量，则所有单词的字母都要大写。
重点：全局常量：
· static：是所有对象共享的
· final：是一个常量
· public：表示可以让外部看见
public static final String FLAG = "";    全局常量
抽象类

抽象类：包含一个抽象方法的类就称为抽象类。
抽象方法：只声明而未实现的方法称为抽象方法。
方法没有方法体（方法体：“{}”），则称为是一个抽象方法。
除了抽象方法之外其他的定义如同普通类一样。
抽象类 = 普通类的功能 抽象方法
abstract class A    
{    
        public static final String FLAG = "";    
        public void print()    
        {    
                //有方法体，所以是一个普通方法    
                System.out.println("Hello World~~~");    
        }        
        //此处定义了一个抽象方法    
        public abstract void fun();    
};    
public class Demo04    
{    
        public static void main(String args[])    
        {    
                A a = new A();    
        }    
};

如果要使用一个抽象类，不能直接实例化，抽象类是必须有子类的。
抽象类必须被继承，被继承的子类如果不是一个抽象类的话，则肯定要覆写全部的抽象方法。
abstract class A    
{    
        public static final String FLAG = "";    
        public void print()    
        {    
                //有方法体，所以是一个普通方法    
                System.out.println("Hello World~~~");    
        }        
        //此处定义了一个抽象方法    
        public abstract void fun();    
};    
//子类中覆写了抽象类中的全部抽象方法    
class B extends A    
{    
        public void fun()    
        {    
                //super.FLAG也可以写成FLAG,因为FLAG已经是全局常量了哈~~~    
                System.out.println("FLAG="+super.FLAG);    
        }    
};    
public class Demo04    
{    
        public static void main(String args[])    
        {    
                B b = new B();    
                b.fun();    
                b.print();    
        }    
};
验证效果，证明抽象类必须这样写哈~~~

抽象类的定义

抽象类的使用规则

抽象类的思考

abstract class Person    
{    
        //Person类应该有姓名和年龄    
        private String name;    
        private int age;    
        public Person(String name,int age)    
        {    
                this.name = name;    
                this.age = age;    
        }    
        public void setName(String name)    
        {    
                this.name = name;    
        }    
        public void setAge(int age)    
        {    
                this.age = age;    
        }    
        public String getName()    
        {    
                return this.name;    
        }    
        public int getAge()    
        {    
                return this.age;    
        }    
        //定义一个输出方法，但是此方法为抽象方法    
        public abstract String getInfo();    
};
我们测试一下，发现编译正常，说明抽象类可以有构造方法哈~

我们继续哈~
abstract class Person    
{    
        //Person类应该有姓名和年龄    
        private String name;    
        private int age;    
        public Person(){}    
        //如果已经不是无参的，则必须在子类中明确调用无参构造    
        public Person(String name,int age)    
        {    
                this.name = name;    
                this.age = age;    
        }    
        public void setName(String name)    
        {    
                this.name = name;    
        }    
        public void setAge(int age)    
        {    
                this.age = age;    
        }    
        public String getName()    
        {    
                return this.name;    
        }    
        public int getAge()    
        {    
                return this.age;    
        }    
        //定义一个输出方法，但是此方法为抽象方法    
        public abstract String getInfo();    
};    
class Student extends Person    
{    
        public Student(String name,int age)    
        {    
                //调用Person类中有两个参数的构造方法    
                super(name,age);    

        }    
        //覆写父类的抽象方法    
        public String getInfo()    
        {    
                return "姓名："+super.getName()+"，年龄："+super.getAge();    
        }    
};    
public class Demo05    
{    
        public static void main(String args[])    
        {    
                Student s = new Student("王乾",27);    
                System.out.println(s.getInfo());    
        }    
}

抽象类中允许有构造方法，但是此构造方法并不是直接实例化抽象类自己的对象使的，如果在抽象类中没有明确的无参构造方法，即：存在有参构造，则必须在子类明确的使用super指明要调用父类中的那个构造方法。
注意：
如果一个抽象类中没有任何一个抽象方法，则也是不能直接实例化的。
abstract class A    
{    
        public void print(){}    
};    
public class Demo06    
{    
        public static void main(String args[])    
        {    
                new A();    
        }    
};

final可以声明一个类，但是此类是绝对不能有子类的。
而抽象类又必须被子类继承。 ==>矛盾的
final abstract class A    
{    
};
验证下效果，我们发现抽象类是不能使用final声明的。

如果假设一个类就是抽象方法和常量的集合，那么此时往往都不再使用抽象类声明了，而使用接口声明。
接口（interface）

interface A    
{    
        //接口中包含了抽象方法和全局常量    
        public static String NAME="";    
        public abstract void print();    
};
接口的使用规则（1）

一个子类继承接口实际上称为实现了接口。
如果实现接口的子类不是抽象类的话，则子类必须覆写接口中的全部抽象方法。
interface A    
{    
        //接口中包含了抽象方法和全局常量    
        public static String NAME="";    
        public abstract void print();    
};    
class B implements A    
{    
        public void print()    
        {    
                System.out.println("NAME="+NAME);    
        }    
};    
public class Demo09    
{    
        public static void main(String args[])    
        {    
                B b = new B();    
                b.print();    
        }    
};

接口使用的事项：
1、抽象类使的是extends关键字，表示一个类只能继承一个父类，但是接口不同，一个类可以同时实现多个接口，但是此时子类就必须同时覆写好多个接口中的抽象方法。
interface A    
{    
        //接口中包含了抽象方法和全局常量    
        public static String NAME="";    
        public abstract void print();    
};    
interface X    
{    
        public abstract void fun();    
};    
class B implements A,X    
{    
        public void print()    
        {    
                System.out.println("NAME="+NAME);    
        }    
        public void fun()    
        {    
                this.print();    
        }    
};    
public class Demo10    
{    
        public static void main(String args[])    
        {    
                B b = new B();    
                b.fun();    
        }    
};

抽象类拥有单继承的局限，而接口没有此限制，即：一个子类可以同时实现多个接口。
2、既然在定义中已经明确的说明了接口是抽象方法和全局常量的集合，则在定义接口的时候就可以简单定义。
interface A    
{    
        //接口中包含了抽象方法和全局常量    
        //public static String NAME="";    
        String NAME="";    
        //public abstract void print();    
        void print();    
};    
class B implements A    
{    
        public void print()    
        {    
                System.out.println("NAME="+NAME);    
        }    
};    
public class Demo11    
{    
        public static void main(String args[])    
        {    
                B b = new B();    
                b.print();    
        }    
};
简化后实现的效果一样哈~

一般习惯在简化时还在前面加上public,呵呵~~~
interface A    
{    
        //接口中包含了抽象方法和全局常量    
        //public static String NAME="";    
        public String NAME="";    
        //public abstract void print();    
        public void print();    
};    
class B implements A    
{    
        public void print()    
        {    
                System.out.println("NAME="+NAME);    
        }    
};    
public class Demo12    
{    
        public static void main(String args[])    
        {    
                B b = new B();    
                b.print();    
        }    
};

接口的使用规则（2）

interface A    
{    
        public void printA();    
}    
interface B    
{    
        public void printB();    
}    
interface C extends A,B    
{    
        public void printC();    
}    
class X implements C    
{    
        //如果实现了（继承）C接口，则在子类中就必须覆写全部的抽象方法    
        public void printA()    
        {    
                System.out.println("A接口 ===> Hello World~~~");    
        }    
        public void printB()    
        {    
                System.out.println("B接口 ===> Hello World~~~");    
        }    
        public void printC()    
        {    
                System.out.println("C接口 ===> Hello World~~~");    
        }    
}    
public class Demo13    
{    
        public static void main(String args[])    
        {    
                X x = new X();    
                x.printA();    
                x.printB();    
                x.printC();    
        }    
}

如果一个子类即要实现一个接口又要继承一个抽象类呢？
则此时按以下格式编写：
class 类名称 extends 抽象类 implements 接口
interface X    
{    
        public void printX();    
}    
interface Y    
{    
        public void printY();    
}    
//一个抽象类也是可以实现接口的    
abstract class Z implements Y    
{    
        public abstract void printZ();    
}    
//D类同时继承Z类和实现X接口    
class D extends Z implements X    
{    
        public void printX()    
        {    
                System.out.println("X ===>Hello~~~");    
        }    
        public void printY()    
        {    
                System.out.println("Y ===>Hello~~~");    
        }    
        public void printZ()    
        {    
                System.out.println("Z ===>Hello~~~");    
        }    
}    
public class Demo14    
{    
        public static void main(String args[])    
        {    
                D d = new D();    
                d.printX();    
                d.printY();    
                d.printZ();    
        }    
}

总结
1、final关键字
2、抽象类与接口的定义及基本使用