你可以这样理解{:3_57:} 童鞋：
抽象类只是一种规范开发的使用方式,属于java的一种模式,规定继承于这个类的子类必须要自己实现抽象方法,是不可以存在非抽象方法的
我想，之所以把一个类声明为abstract，是因为想通过这个简单的声明方式使这个被声明的类不能被实例化，也就是说使任何人都不能在这个抽象类上使用new来实例化对象。
但是你继承了这个类就必须按软件设计人员的标准对他定义的抽象方法进行实现,这是属于java开发的一种规范,你要理解为你是一个程序员,你只能按照软件设计人员的思想设计自己的代码,而不是你一个人完成全部开发
在面向对象的范围,你继承于他的类,必定和他的类有一定的关系,至少存在共性
--------------举一个-----------
抽象类里没抽象方法的例子
都知道抽象类可以没有抽象方法,这时的抽象类和普通类的最大差别就是不能实例化.一直没找到在什么环境下用到这种特殊的抽象类.最近看了jdk的I/O包后,发现里面有个很好的例子,就是FilterReader类.以下是FilterReader的代码:
public abstract class FilterReader extends Reader {
/**
* The underlying character-input stream.
*/
protected Reader in;
/**
* Create a new filtered reader.
*
* @param in a Reader object providing the underlying stream.
* @throws NullPointerException if <code>in</code> is <code>null</code>
*/
protected FilterReader(Reader in) {
super(in);
this.in = in;
}
/**
* Read a single character.
*
* @exception IOException If an I/O error occurs
*/
public int read() throws IOException {
return in.read();
}
/**
* Read characters into a portion of an array.
*
* @exception IOException If an I/O error occurs
*/
public int read(char cbuf[], int off, int len) throws IOException {
return in.read(cbuf, off, len);
}
/**
* Skip characters.
*
* @exception IOException If an I/O error occurs
*/
public long skip(long n) throws IOException {
return in.skip(n);
}
/**
* Tell whether this stream is ready to be read.
*
* @exception IOException If an I/O error occurs
*/
public boolean ready() throws IOException {
return in.ready();
}
/**
* Tell whether this stream supports the mark() operation.
*/
public boolean markSupported() {
return in.markSupported();
}
/**
* Mark the present position in the stream.
*
* @exception IOException If an I/O error occurs
*/
public void mark(int readAheadLimit) throws IOException {
in.mark(readAheadLimit);
}
/**
* Reset the stream.
*
* @exception IOException If an I/O error occurs
*/
public void reset() throws IOException {
in.reset();
}
/**
* Close the stream.
*
* @exception IOException If an I/O error occurs
*/
public void close() throws IOException {
in.close();
}
}
可以看到FilterReader就是一个没有抽象方法的抽象类,里面的每个方法都是转调用构造函数传入Reader对象的方法.这种抽象类你不能实例化它,因为实例化它没意义,它还没实现任何Filter的功能.在extends字的具体子类实现了Filter功能,实例化相应的子类才有实际意义.
我们可以写FilterReader的一个具体子类如下:
/**
* FilterReader是一个抽象类,不能实例化该类,FilterReader类的每个方法都是实现的,
* 里面调用的都是FilterReader(Reader in)的传入参数in的方法.
*/
public class UppercaseConvertor extends FilterReader{
// 构造方法由FilterReader的protected上升到public的
public UppercaseConvertor(Reader in) {
super(in);
}
@Override
public int read() throws IOException{
int c = super.read();
return (-1==c?c:Character.toUpperCase((char)c));
}
@Override
public int read(char[] buf,int offset, int count) throws IOException{
int nread = super.read(buf, offset, count);
int last = offset + nread;
for(int i=0;i<last;i++)
buf[i] = Character.toUpperCase(buf[i]);
return nread;
}
public static void main(String[] args) throws IOException {
UppercaseConvertor uc = new UppercaseConvertor(new FileReader("d:/log.txt"));
BufferedReader br = new BufferedReader(uc);
String r;
while(null!=(r=br.readLine())){
System.out.println(r);
}
}
}
这里的FilterReader其实起了一种强制子类类型化(FilterReader)的作用. |
收藏
淘帖
踩
