上季内容回顾:
1、super与this关键字 
2、方法的重载与覆写
本季主要知识点:
1、final关键字 
2、简单了解一下抽象类与接口(是JAVA中最重要的部分)
final关键字
image
终结器 —— final
1、被final标记的类不能被继承 
final class A    
{    
};    
class B extends A    
{    
};
验证一下:
image
2、被final标记的方法不能被子类覆写
final class A    
{    
        public final void print(){}    
};    
class B extends A    
{    
        public void print(){}    
};
image
3、被final标记的变量就成为常量,如果成为常量,则以后不能修改
class A    
{    
        final String NAME = "Hello";    
        public final void print()    
        {    
                NAME = "World";    
        }         
};
image
之前在声明变量的时候是第一个单词的首字母小写,之后每个单词的首字母大写。如果使用final声明常量,则所有单词的字母都要大写。
重点:全局常量: 
· static:是所有对象共享的 
· final:是一个常量 
· public:表示可以让外部看见
public static final String FLAG = "http://redking.blog.51cto.com";    全局常量
抽象类
image
抽象类:包含一个抽象方法的类就称为抽象类。 
抽象方法:只声明而未实现的方法称为抽象方法。 
方法没有方法体(方法体:“{}”),则称为是一个抽象方法。
除了抽象方法之外其他的定义如同普通类一样。 
抽象类 = 普通类的功能 + 抽象方法
abstract class A    
{    
        public static final String FLAG = "redking.blog.51cto.com";    
        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();    
        }    
};
image
如果要使用一个抽象类,不能直接实例化,抽象类是必须有子类的。 
抽象类必须被继承,被继承的子类如果不是一个抽象类的话,则肯定要覆写全部的抽象方法。
abstract class A    
{    
        public static final String FLAG = "redking.blog.51cto.com";    
        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();    
        }    
};
验证效果,证明抽象类必须这样写哈~~~
image
抽象类的定义
image
抽象类的使用规则
image
抽象类的思考
image
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();    
};
我们测试一下,发现编译正常,说明抽象类可以有构造方法哈~
image
我们继续哈~
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());    
        }    
}
image
抽象类中允许有构造方法,但是此构造方法并不是直接实例化抽象类自己的对象使的,如果在抽象类中没有明确的无参构造方法,即:存在有参构造,则必须在子类明确的使用super指明要调用父类中的那个构造方法。
注意: 
如果一个抽象类中没有任何一个抽象方法,则也是不能直接实例化的。
abstract class A    
{    
        public void print(){}    
};    
public class Demo06    
{    
        public static void main(String args[])    
        {    
                new A();    
        }    
};
image
final可以声明一个类,但是此类是绝对不能有子类的。 
而抽象类又必须被子类继承。 ==>矛盾的
final abstract class A    
{    
};
验证下效果,我们发现抽象类是不能使用final声明的。
image
如果假设一个类就是抽象方法和常量的集合,那么此时往往都不再使用抽象类声明了,而使用接口声明。
接口(interface)
image
interface A    
{    
        //接口中包含了抽象方法和全局常量    
        public static String NAME="redking.blog.51cto.com";    
        public abstract void print();    
};
接口的使用规则(1)
 image
一个子类继承接口实际上称为实现了接口。 
如果实现接口的子类不是抽象类的话,则子类必须覆写接口中的全部抽象方法。
interface A    
{    
        //接口中包含了抽象方法和全局常量    
        public static String NAME="redking.blog.51cto.com";    
        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();    
        }    
};
image 
接口使用的事项: 
1、抽象类使的是extends关键字,表示一个类只能继承一个父类,但是接口不同,一个类可以同时实现多个接口,但是此时子类就必须同时覆写好多个接口中的抽象方法。
interface A    
{    
        //接口中包含了抽象方法和全局常量    
        public static String NAME="redking.blog.51cto.com";    
        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();    
        }    
}; 

image
抽象类拥有单继承的局限,而接口没有此限制,即:一个子类可以同时实现多个接口。
2、既然在定义中已经明确的说明了接口是抽象方法和全局常量的集合,则在定义接口的时候就可以简单定义。
interface A    
{    
        //接口中包含了抽象方法和全局常量    
        //public static String NAME="redking.blog.51cto.com";    
        String NAME="redking.blog.51cto.com";    
        //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();    
        }    
};
简化后实现的效果一样哈~
image
一般习惯在简化时还在前面加上public,呵呵~~~
interface A    
{    
        //接口中包含了抽象方法和全局常量    
        //public static String NAME="redking.blog.51cto.com";    
        public String NAME="redking.blog.51cto.com";    
        //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();    
        }    
};
image
接口的使用规则(2)
image
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();    
        }    
}
image
如果一个子类即要实现一个接口又要继承一个抽象类呢? 
则此时按以下格式编写: 
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();    
        }    
}
image
总结 
1、final关键字 
2、抽象类与接口的定义及基本使用
ps:谨以此文庆祝本blog突破20W访问量,希望在2009年获得新的突破,得到技能的提升,下季我们将一起来学习多态哈~~~
#########################################################################