[零基础学JAVA]Java SE面向对象部分-15.面向对象高级(03)
2009-01-13 20:20
459 查看
上季内容回顾:
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 = "http://redking.blog.51cto.com"; 全局常量 抽象类 抽象类:包含一个抽象方法的类就称为抽象类。
抽象方法:只声明而未实现的方法称为抽象方法。
方法没有方法体(方法体:“{}”),则称为是一个抽象方法。 除了抽象方法之外其他的定义如同普通类一样。
抽象类 = 普通类的功能 + 抽象方法 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();
}
}; 如果要使用一个抽象类,不能直接实例化,抽象类是必须有子类的。
抽象类必须被继承,被继承的子类如果不是一个抽象类的话,则肯定要覆写全部的抽象方法。 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
{
publ 24000 ic 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="redking.blog.51cto.com";
public abstract void print();
}; 接口的使用规则(1) 一个子类继承接口实际上称为实现了接口。
如果实现接口的子类不是抽象类的话,则子类必须覆写接口中的全部抽象方法。 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();
}
}; 接口使用的事项:
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();
}
};
抽象类拥有单继承的局限,而接口没有此限制,即:一个子类可以同时实现多个接口。 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();
}
}; 简化后实现的效果一样哈~ 一般习惯在简化时还在前面加上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();
}
}; 接口的使用规则(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、抽象类与接口的定义及基本使用 ps:谨以此文庆祝本blog突破20W访问量,希望在2009年获得新的突破,得到技能的提升,下季我们将一起来学习多态哈~~~ ######################################################################### 阅读更多
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 = "http://redking.blog.51cto.com"; 全局常量 抽象类 抽象类:包含一个抽象方法的类就称为抽象类。
抽象方法:只声明而未实现的方法称为抽象方法。
方法没有方法体(方法体:“{}”),则称为是一个抽象方法。 除了抽象方法之外其他的定义如同普通类一样。
抽象类 = 普通类的功能 + 抽象方法 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();
}
}; 如果要使用一个抽象类,不能直接实例化,抽象类是必须有子类的。
抽象类必须被继承,被继承的子类如果不是一个抽象类的话,则肯定要覆写全部的抽象方法。 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
{
publ 24000 ic 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="redking.blog.51cto.com";
public abstract void print();
}; 接口的使用规则(1) 一个子类继承接口实际上称为实现了接口。
如果实现接口的子类不是抽象类的话,则子类必须覆写接口中的全部抽象方法。 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();
}
}; 接口使用的事项:
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();
}
};
抽象类拥有单继承的局限,而接口没有此限制,即:一个子类可以同时实现多个接口。 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();
}
}; 简化后实现的效果一样哈~ 一般习惯在简化时还在前面加上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();
}
}; 接口的使用规则(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、抽象类与接口的定义及基本使用 ps:谨以此文庆祝本blog突破20W访问量,希望在2009年获得新的突破,得到技能的提升,下季我们将一起来学习多态哈~~~ ######################################################################### 阅读更多
相关文章推荐
- [零基础学JAVA]Java SE面向对象部分-15.面向对象高级(03) 推荐
- [零基础学JAVA]Java SE面向对象部分-13.面向对象高级(01) 推荐
- [零基础学JAVA]Java SE面向对象部分-17.面向对象高级(05)
- [零基础学JAVA]Java SE面向对象部分-17.面向对象高级(05) 推荐
- [零基础学JAVA]Java SE面向对象部分-18.面向对象高级(06) 推荐
- [零基础学JAVA]Java SE面向对象部分-14.面向对象高级(02) 推荐
- [零基础学JAVA]Java SE面向对象部分-19.面向对象高级(07) 推荐
- [零基础学JAVA]Java SE面向对象部分.面向对象基础(03)
- [零基础学JAVA]Java SE面向对象部分-16.面向对象高级(04) 推荐
- [零基础学JAVA]Java SE面向对象部分-08.面向对象基础(03)
- [零基础学JAVA]Java SE面向对象部分-12.面向对象基础(07) 推荐
- [零基础学JAVA]Java SE面向对象部分-09.面向对象基础(04)
- [零基础学JAVA]Java SE面向对象部分-10.面向对象基础(05)
- [零基础学JAVA]Java SE面向对象部分.面向对象基础(06)
- [零基础学JAVA]Java SE面向对象部分.面向对象基础(05)
- [零基础学JAVA]Java SE面向对象部分.面向对象基础(04)
- [零基础学JAVA]Java SE面向对象部分.面向对象基础(02)
- [零基础学JAVA]Java SE面向对象部分.面向对象基础(01)
- [零基础学JAVA]Java SE面向对象部分-06.面向对象基础(01)
- [零基础学JAVA]Java SE面向对象部分-11.面向对象基础(06) 推荐