【转载】 J2SE知识点归纳笔记(三)---Java面向对象 Part 3

注：本文转载自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

封装:

将数据与数据操作绑定到一个类中，这样的方法就保证了程序中的数据不会受到外部代码的影响

在Java中通常是将属性设置为private,然后再类中设置getXxx()和putXxx()方法对数据进行操作

从而保证代码的独立性,而且能够比较容易地对程序进行维护和修改

总结:

在面向对象的最后一节,在这一节中我们对抽象类,接口

各种修饰符,枚举和封装进行了深入的解析

Java面向对象知识点到此结束,我们学会的仅仅是基础

需要在编程中进行巩固,大家要做下相关的编程题目

做多了,知识点也就记得了！

如果文中有遗漏,错误,好的建议;

望读者指出,万分感激！！(*^__^*) 嘻嘻……