注:本文转载自coder-pig
原文请戳:http://blog.csdn.net/coder_pig/article/details/22667533
总体来说小猪的文章写的挺详细,这个家伙挺有耐心的,稍安勿躁,一步步来~
Java面向对象 Part 3
前言
在前面的两节中我们对面向对象已经有了差不多的了解了,
而这一节也是Java面向对象部分的一个结尾,
在这一节中我们会对抽象类,接口,修饰符,枚举,封装进行解析;
抽象类
什么是抽象类?
我们将具有共同特点的类进行抽象后得到的一个类,而这个类本身的方法并没有任何具体的实现;
eg:定义一个抽象的动物类,然后定义几个抽象方法(动物共有的方法),比如设置有多少只脚的方法
public abstract void setFoods();
抽象类的定义:
一般使用abstract关键字修饰
抽象类: 修饰符 abstract 类名{//类的内容}
抽象方法: 修饰符 abstract 返回值类型 方法名();
抽象类的使用规则:
①如果一个类有一个抽象方法,那么这个类一定是抽象类;反之,如果一个类是抽象类,但可能包含有非抽象的方法
②如果一个类继承了一个抽象类,那么必须重写抽象类中所有的抽象方法,是所有!所有!如果没有全部实现的话
那么子类必须也要定义为一个抽象类
③abstract不能和static放在一起,否则会出现错误(因为static不能被覆盖,abstract为了生效,必须被覆盖)
④抽象类可不能定义为最终哦!abstract不能与final共存!
⑤注意区分方法的空实现和方法的抽象
eg:方法的空实现:private void show(){} 方法的抽象,无实现: private void show();
⑥抽象类不能够实例化哦!但是可以new的时候重写里面的抽象方法
抽象类使用实例
代码:
- package com.jay.example;
- /*
- * 该代码是定义一个抽象类,汽车类,定义几个属性和抽象方法
- * 然后定义客车,吊车类作为它的子类,
- * 在客车类中即重写抽象方法,也重写了具体方法
- * 在吊车类中,只是重写具体方法,不重写抽象方法,所以吊车类
- * 需要被设置为抽象类,否则会报错
- * */
- abstract class Car
- {
- protected String color;
- protected int sudu;
- //定义一个具体的方法
- public void speed()
- {
- System.out.println("加速");
- }
- //定义一个抽象方法,是方法的空实现哦,子类继承时需要覆盖该方法
- public abstract void useful();
- }
- class Truck extends Car
- {
- public void speed()
- {
- System.out.println("卡车起步很慢");
- }
- public void useful() {
- System.out.println("卡车是用于货运的!");
- }
- }
- //定义吊车类,没有实现抽象方法,所以需为抽象类
- abstract class Crane extends Car
- {
- public void speed() {
- System.out.println("吊车走得更加慢!");
- }
- }
- public class AbstractDemo {
- //抽象类可不能直接实例化哦!Car c = new Car()是会报错的
- //当然可以通过向上转型的规则:Car c = new Track();是可以的
- public static void main(String[] args) {
- Truck tr = new Truck();
- tr.speed();
- tr.useful();
- //下面是演示protected修饰的作用于,子类或者同包可见
- tr.color = "白色";
- tr.sudu = 40;
- System.out.println(tr.color + tr.sudu + "km/h");
- }
- }
运行截图:
代码解析:
该代码演示了抽象类的基本用法,定义抽象类父类Car,定义了一个抽象方法和具体方法
然后在卡车类中都重写了两个方法;在吊车类中仅仅重写了具体方法,所以吊车类需要被设置为抽象类
最后还演示了protected的作用域:子类与同包可见
接口
接口的介绍:
因为Java的数据结构是树型的,所以不像C++那样可以同时继承多个父类;但是Java通过接口和内部类实现了多继承
接口是一种特殊的抽象类,一个类实现一个接口,相当于它继承了一个抽象类
接口的定义:
修饰符 inteface 接口名{"内容"}
接口的实现:
一个类可以在继承一个父类同时实现多个接口,用","分隔
class 类名 extents 父类 implements 接口1,接口2...{}
使用规则:
①一个Java文件中只允许有一个public修饰的类或者接口,且需与文件名同名,是一个!!
②在一个接口中,所有方法都是公开的,抽象的方法!!所有的属性都是公开,静态,常量!
③如果一个类声明实现一个接口,但是没有实现接口中的所有方法,那么这个类必须是抽象类哦!
④接口只关心功能,并不关心功能的具体实现
⑤接口也可以通过extends继承哦!但是依旧需要实现子接口和父接口中的所有抽象方法
⑥接口中的方法可以不写public,但是子类实现接口中的抽象方法时,要写上public,不然会报错哦!
代码示例:
- package com.jay.example;
- /*
- * 在这个代码中,我们定义了两个父接口,又用一个子接口对两个父接口进行了继承
- * 同时为子接口又定义了一个抽象方法;然后定义了一个Person实现两个父接口
- * 重写了两个抽象方法;又定义了一个Worker实现了子接口,但同时也需要把父接口
- * 中的抽象方法进行覆盖
- *
- * */
- //定义一个说话的接口
- interface Speak
- {
- void speak();
- }
- //定义一个吃饭的接口
- interface Eat
- {
- void eat();
- }
- //定义一个子接口,同时继承说话和吃饭的接口,同时定义一个走路的方法
- interface Walk extends Speak,Eat
- {
- void walk();
- }
- //定义一个Person类,实现说话和吃饭接口,重写接口中的抽象方法
- //子类在实现接口的时候,public修饰符不可以省略,不然会报错
- class Person implements Speak,Eat
- {
- public void speak()
- {
- System.out.println("Person类可以说话");
- }
- public void eat()
- {
- System.out.println("Person类可以吃饭");
- }
- }
- //定义一个Worker类直接实现walk接口,同时要实现两个父接口中的抽象方法
- class Worker implements Walk
- {
- public void speak()
- {
- System.out.println("Worker类可以说话");
- }
- public void eat()
- {
- System.out.println("Worker类可以吃饭");
- }
- public void walk()
- {
- System.out.println("Worker类可以走路");
- }
- }
- public class InterfaceTest {
- public static void main(String[] args) {
- //实例化两个对象,输出对应结果
- Person p = new Person();
- p.eat();
- p.speak();
- Worker w = new Worker();
- w.eat();
- w.speak();
- w.walk();
- }
- }
代码截图:
代码解析:
该代码演示了接口的继承,接口的实现
比较简单,这里就略过了
修饰符详解
访问控制修饰符
public:公有的,被public修饰的部分可以被任何程序访问
protected:受保护的,被它修饰的成员只能由同包中的类或者其子类访问
default(默认):不写修饰符就是默认的,别写上defalut啊!同包与同类可见
private:私有的,是Java实现封装的关键,被修饰的成员变量与方法只能被类本身访问,同包也不行哦!
注意事项:
不能够使用protected和private修饰类;要么用public修饰,要么不加任何修饰符
其他修饰符:
static:静态修饰符
①静态变量:
用static修饰的变量,在所有对象中共享的数据,都指向内存中的同一地址
即,任何对象对改值的修改都会使存储空间的值发生改变
代码演示:
- package com.jay.example;
- class Test
- {
- //定义初始的值为3
- static int a = 3;
- }
- public class StaticTest {
- public static void main(String[] args) {
- //静态成员变量可以直接通过类名进行访问
- System.out.println(Test.a);
- //实例化两个对象,在t1中修改a的值,发现t2中的a的值也发生改变
- Test t1 = new Test();
- t1.a = 4;
- Test t2 = new Test();
- System.out.println(t2.a);
- //输出结果是:
- //3
- //4
- //说明了静态变量都是公用一块内存区域的,任何一个对象
- //对值的修改,都会改变对应内存区域的值
- }
- }
②静态方法:
用static修饰的方法,要注意:
静态方法中,只能够访问静态数据或者直接调用静态方法
可以直接通过类名进行调用
代码演示:
- package com.jay.example;
- /*
- *因为我们的main方法就是静态的方法
- *所以我们直接在main方法外定义参数和方法
- *验证静态方法只能访问静态成员
- * */
- public class StaticTest2 {
- //定义非静态的数据与方法
- int a = 3;
- void test(){System.out.println("非静态方法可不能被main调用啊");}
- //定义静态的数据和方法
- static int b = 4;
- static void test2()
- {System.out.println("静态方法被main调用了");}
- public static void main(String[] args) {
- //下面两个语句,如果调用了是会报错的,不信可以试试
- //System.out.println(a);
- //test();
- System.out.println(b);
- test2();
- }
- }
③静态代码块
放在类声明的内部,成员方法与构造方法的外部,该代码块会在该类第一次使用时
执行一次,就不会再执行了,通常是在这里写一些初始化的代码
代码演示:
- package com.jay.example;
- public class static3 {
- static
- {
- System.out.println("静态代码块,通常用于类的初始化");
- }
- }
④复杂的成员的初始化问题
当静态数据,静态代码块,对象成员,构造方法等同时存在时,那么成员的初始化顺序又是怎样呢?
其实,初始化顺序是:(静态变量,静态初始化块) --->(变量,变量初始化块)---->构造器
下面我们通过代码来验证这一规律:
- package com.jay.example;
- public class static3 {
- public static String staticStr = "静态成员初始化";
- public String str = "普通成员初始化";
- //构造方法
- public static3() {
- System.out.println("构造方法初始化");
- }
- //普通的初始化块
- {
- System.out.println(str);
- System.out.println("普通的初始化块");
- }
- //静态的初始化块
- static
- {
- System.out.println(staticStr);
- System.out.println("静态的初始化块");
- }
- public static void main(String[] args) {
- static3 st = new static3();
- }
- }
运行截图:
final:最终修饰符
使用方法
①使用final修饰属性(变量),此时的属性为常量;Java中利用public static final int AGE = 10;对常量进行标识
②空白final变量(没初始化的):空白的final数据成员必须在构造方法中进行初始化,否则会报错
③final常量作为方法的参数,只能够对final进行简单的引用,可不能改变常量的值哦!
④用final来修饰方法:那么该方法为一个不可覆盖的方法,如果父类有final修饰的方法,那么子类继承同一个方法
⑤用final来修饰类:那么该类不可以被继承,final类没有子类;同时该类中所有的方法都默认为final
⑥final并不涉及继承,继承取决于类的修饰符是public还是其他,是否可以继承取决于该类是否对其子类可见
如果一个方法前有private或static的修饰符,那么系统在前面自动地加上final修饰
abstract:抽象修饰符
被abstract修饰的类为抽象类,修饰的方法为抽象方法
transient:
用于修饰不想序列化,持久化的成员
volatile:
保证可见性和防止重排序,用的比较少,是并发操作那块的
枚举类型
枚举解析:
①作为jdk 1.5 后引入的枚举,用来代替以前定义多个同类型常量的public final static
②用enum表示,作用类似于class关键字;
③构造方法不要用public修饰
④变量和方法的定义需要在枚举值的后面!!!
用法示例:
简单的枚举:
- package com.jay.example;
- /*
- * 本程序演示的是枚举的最简单用法
- * 定义枚举Color有三个值,演示了switch和增强for循环遍历枚举
- * 中所有的原始的方法
- * */
- enum Color
- {
- BLUE,RED,YELLOW;
- }
- public class EnumTest {
- public void printColor(Color color)
- {
- switch(color)
- {
- case BLUE:
- System.out.println("输出蓝色!");
- break;
- case RED:
- System.out.println("输出红色!");
- break;
- case YELLOW:
- System.out.println("输出黄色!");
- break;
- }
- }
- public static void main(String[] args) {
- EnumTest test = new EnumTest();
- test.printColor(Color.BLUE);
- test.printColor(Color.RED);
- test.printColor(Color.YELLOW);
- //当然也可以直接用增强for循环来遍历枚举中所有的值:
- //可以通过values()方法获得枚举的数组
- for(Color c : Color.values())
- {
- System.out.println(c);
- }
- }
- }
运行截图:
深一步的使用:
- package com.jay.example;
- /*
- * 本代码演示的是枚举类的进一步使用
- * 和类一样,枚举可以定义自己的属性和方法,但是
- * 必须写在枚举列表的后面,不然会报编译时错误
- * */
- public class EnumTest2 {
- public enum Color
- {
- //枚举可以像一般的类一样添加方法和属性
- Red("红色"),BLUE("蓝色"),YELLOW("黄色");
- //构造方法,不要写public修饰!
- Color(String value)
- {
- this.value = value;
- }
- //定义一个成员变量
- private final String value;
- //定义一个获取后面值得方法
- public String getValue()
- {
- return value;
- }
- }
- public static void main(String[] args) {
- EnumTest2 test = new EnumTest2();
- //可以通过for循环调用获得枚举中所有的值
- for(Color color : Color.values())
- {
- System.out.println(color);
- System.out.println(color.getValue());
- }
- //可以通过ordinal获得枚举值在枚举中的索引位置,从0开始的
- System.out.println(Color.BLUE.ordinal());
- //枚举默认实现了java.lang.Comparable接口,可以直接调用compareTo对枚举值进行比较
- //这里Red在Blue前面,所以是-1
- System.out.println(Color.Red.compareTo(Color.BLUE));
- }
- }
运行截图:
小结:
在这里,我们仅仅演示了enum枚举类型的两种基本用法,
如果有兴趣深入研究枚举的可以参考以下文档:Java枚举类型详解
http://pan.baidu.com/s/1o6qHLUy