说了开始复习基础了,虽然以前也做过笔记,而且现在属于复习,在考虑是否还要写笔记包括blog是否要写这些东西,想了好久,还是写写吧,不然一天干了什么都不知道..
抽象类
- 在定义java方法时可以只给出方法头,而不必给出方法体,即方法实现的细节,这样的方法被称为抽象方法。
- 抽象方法必须使用关键字abstract修饰,包含抽象方法的类必须声明为抽象类。
- java语法规定,子类必须实现父类中的所有抽象方法,否则改子类也只能声明为抽象类。
- 抽象类不能被实例化。
public abstract class Animal
{
private int age;
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
public abstract void eat();
}
public class Person extends Animal
{
private String name;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void eat(){
//重写方法
System.out.println("洗手--做饭--吃饭--收拾");
}
}
public class Test
{
public static void main(String[] args){
Animal a=new Person();//正确
//Animal a=new Animal(); 错误
a.setAge(2);
a.eat();
}
}
抽象类主要是通过继承、再由其子类发挥作用的,其中作用包括两方面:
- 代码的重用
- 规划
其他特性:
- 抽象类中可以不包含抽象方法;
- 子类中可以不全部实现抽象父类中的抽象方法,但是此时子类也只能声明为抽象类;
- 父类不是抽象类,但在子类中可以添加抽象方法,但子类需声明为抽象类;
- 抽象类中可以声明static属性和方法
接口
- 接口(interface)是抽象方法和常量值的定义的集合。
- 从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现。
public interface Runner
{
public static final int id=1;
public abstract void start();
public abstract void run();
public abstract void stop();
}
- 接口中定义的属性必须是public static final的,而接口中定义的方法则必须是public abstract的,因此这些修饰符可以是部分或全部
public interface Runner
{
public static final int id=1;
public abstract void start();
public abstract void run();
public abstract void stop();
}
等价于------------------------------------------------->
public interface Runner
{
int id=1;
void start();
void run();
void stop();
}
- 和继承关系类似,java类可以"实现"接口,且接口和实现类之间也存在多态性。
[<modifier>] class <name> [extends <superclass>]
[implements <interface> [,<interface>]*]{
declarations>*
}
public class Person implements Runner
{
public void start(){
System.out.println("弯腰,准备,开跑");
}
public void run(){
System.out.println("加速冲向终点");
}
public void stop(){
System.out.println("胜利,休息");
}
}
public class Test
{
public static void main(String[] args){
Runner r=new Person();
r.start();
r.run();
r.stop();
}
}
- 接口的多重实现
interface Runner{
public void run();
}
interface Swimmer{
public void swim();
}
abstract class Animal{
public abstract void eat();
}
class Person extends Animal implements Runner,Swimmer
{
public void run(){
System.out.println("I am runing");
}
public void swim(){
System.out.println("I am Swimming");
}
public void eat(){
System.out.println("I am eating");
}
}
public class Test{
public static void main(String[] args){
Test t=new Test();
Person p=new Person();
t.m1(p);
t.m2(p);
t.m3(p);
}
public void m1(Runner f){
f.run();
}
public void m2(Swimmer s){
s.swim();
}
public void m3(Animal a){
a.eat();
}
}
输出结果:
I am running
I am swimming
I am eating
接口间的继承
interface A{
public void ma();
}
interface B{
public int mb(int i)
}
interface C extends A,B{
public String mc();
}
class D implements C{
public void ma(){
System.out.println("Implements method ma()");
}
public int mb(int i){
return 2000+i;
}
public String mc(){
return "Hello";
}
}
接口特性总结
- 通过接口可以实现不相关类的相同行为,而不需要考虑这些类之间的层次关系;
- 接口可以被多重实现
- 接口可以继承其它的接口,并添加新的属性和抽象方法,接口间支撑多重继承
嵌套类
java语言支持类的嵌套定义,即允许将一个类定义在其他类的内部,其中内层的类被称为嵌套类(Nested Class)
嵌套类可以分为两种:
- 静态嵌套类(Static Nested Class):使用static修饰的嵌套类;
- 内部类(Inner Class):非static的嵌套类
public class A{
...
private class B{ //内部类
...
}
public static class C{ //静态嵌套类
...
}
}
内部类又可分为三种情况:
- 普通的内部类:在java类中、方法或语句块的外部定义的非static类。
- 局部内部类:也称局部类(Local Class),定义在方法或语句块中的类
- 匿名内部类:也称匿名类(AnonymousClass),定义在方法或语句块中,该类没有名字.只能在其所在之处使用一次
- 内部类与其所在的外层类之间存在着逻辑上的依赖关系——内部类的对象不能单独存在,它必须依赖一个其外层类的对象;
- 在内部类中可以直接访问其外层类中的成员、包括属性和方法,即使在这些属性和方法是private的
- 内部类可以声明为抽象类,因此可以被其它的内部类继承,也可以声明为final的
- 和外层类不同,内部类可以声明为private或protected。
public class A{
private int s;
private class B{
public void mb(){
s=100;
System.out.println("在内部类B中S="+s);
}
}
public void ma(){
B i=new B()
i.mb();
}
}
public class TestInner{
public static void main(String[] args){
A o=new A();
o.ma();
}
}
- 在外部使用其他类中的内部类时,应指明起完整层次,并显示建立对象间的依赖关系。
public class A{
private int s;
private class B{
public void mb(){
System.out.println(s);
}
}
}
public class TestInner2{
public static void main(String[] args){
A a=new A();
//创建一个依赖于a而存在的b
A.B b=a.new B();
b.mb();
}
}
- 内部类中出现变量名冲突时,可以使用内部类对象的特殊性"<外层类名>.this"来访问其所依赖外层类对象的成员.
class A{
private int s=111;
private class B{
private int s=222;
public void mb(int s){
System.out.println(s);//局部变量s
System.out.println(this.s);//内部类对象的属性s
System.out.println(A.this.s);//外层类对象属性s
}
}
}
public class TestInner3{
public static void main(String[] args){
A a=new A();
A.B b=a.new B();
b.mb(333);
}
}
枚举类型
- Java SE5.0开始,java语言引入了一种新的引用数据结构——枚举(Enum).
- Java 语言中枚举类型均自动继承了java.lang.Enum类(该类继承了Object类).
- 枚举类型使用一组常量值来表示特定的数据集合,改集合中数据的数目确定(通常较少),且这些数据只能取预先定义的值。
public enum Week{
Mon,Tue,Wed,Thu,Fri,Sat,Sun
}
public class TestEnum{
public static void main(String[] args){
TestEnum te=new TestEnum();
te.work(Week.Sun);
}
public void work(Week day){
if(day.equals(Week.Sat)){
System.out.println("shopping");
}else if(day.equals(Week.Sun)){
System.out.println("sleep");
}else{
System.out.println("work");
}
}
}