java高级类特性

为什么使用抽象类：

类用于描述现实生活中的一类事物，类中属性、方法。并且方法都有方法体。

某种情况下，父类只能知道子类应该具备一个怎样的方法，但是不能明确知道子类如何实现该方法。

例如：几何图形（多态练习），所有几何图形都应该具备一个计算面积的方法，但是，

不同几何图形计算面积的方式不同。

DAYONGYOYFFDDUDOECBSIXUDESHICHOUXIANGLEI KDJJJDKEBUKEBIYOUN BBUDDMMCF

Java 为上述情况提供了相应的解决办法

Java 允许父类中只是提供一个方法的声明，不提供具体的实现，

具体的实现交给子类来完成，该方法称为“抽象方法”

拥有一个或多个抽象方法的类，称为“抽象类”

一、如何使用抽象类： abstract

1. abstract 修饰的类称为“抽象类”

①格式： 访问控制修饰符 abstract class 类名{}

②拥有一个或多个抽象方法的类必须是抽象类

③抽象类中可以有非抽象方法，抽象类中可以没有抽象方法

④**抽象类不能创建实例

⑤抽象类中可以声明构造器。 目的：当子类继承父类后，继承父类中所有的属性和方法，因此子类需要知道父类如何

为对象进行初始化

2. abstract 修饰的方法称为“抽象方法”

①格式： 访问控制修饰符 abstract 返回值类型 方法名(参数列表);

②子类继承父类后，若重写了父类中“所有”的抽象方法，该类为具体类，可以创建实例

③子类继承父类后，若没有重写父类中“所有”的抽象方法，该类必须是抽象类

例：

public abstract class Person{

private String name;

public Person(){}

public void setName(String name){

this.name = name;

}

//所有的人应该具备说话的功能，但是不同的人说话的方式不同

public abstract void speak();

}

class Chinese extends Person{

public void speak(){

System.out.println("中国人说汉语");

}

}

abstract class American extends Person{

//public abstract void speak();

}

一、接口：可以定义多个不相关事物的相同功能

二、如何使用接口：

①接口与类是平级的

关键字： interface

如：

public interface Flyer{}

②可以把接口理解为特殊的抽象类。 因为接口中只能定义“全局静态常量”和“抽象方法”

//全局静态常量

int NUM = 100;//public static final

//抽象方法

void fly(); //public abstract

③接口中不能有变量、一般方法、构造器、代码块

④**接口不能创建实例

⑤接口就是用来被实现的

实现关键字： implements

如：

class Bird implements Flyer{}

⑥实现接口的类称为“实现类”，实现类的功能和“继承”一样，可以继承接口中所有的成员

⑦若实现类实现了接口中“所有”的抽象方法，该类为具体类，可以创建实例

若实现类没有实现接口中“所有”的抽象方法，该类必须是抽象类

⑧接口可以多实现 --- 解决了 Java 中单继承的局限性

如：

class Bird implements Flyer, Runner{}

⑨接口不能继承任何类，接口可以继承接口，并且可以多继承接口

⑩一个类可以继承另一个类，同时实现多个接口

如：

class Bird extends Animal implements Flyer, Runner{}

注意：先继承，后实现

一、类的成员之一：内部类（属性、方法、构造器、代码块）

1. 成员内部类：类中声明另一个类，里面的类“内部类”，外面的类“外部类”

①是类的成员之一

②可以使用四种访问控制修饰符（public protected default private）

③static final

//创建静态内部类对象

Person.Mobile pm = new Person.Mobile();

pm.show();

//创建非静态内部类对象

//Person p = new Person();

//Person.Computer pc = p.new Computer();

Person.Computer pc = new Person().new Computer();

pc.setName("IBM");

④内部类与外部类的特性一致

class Person{

private String name;

private int age;

public Person(){}

//成员内部类

public class Computer{

private String name;

public void setName(String name){

System.out.println(age);

System.out.println(name);

System.out.println(this.name);

System.out.println(Person.this.name); //区分内部类与外部类的同名属性

}

}

//对类的隐藏

private class Head{}

//静态内部类

static class Mobile{

public void show(){}

}

}

2. 局部内部类：

//如下方式使用非常的少

public void show(){

final int num = 0;

class Inner{

public void show(){

//若局部内部类中使用了同级别的局部变量，该局部变量必须是 final 修饰

System.out.println(num);

}

}

Inner inner = new Inner();

}

//若某个类仅适用于当前方法时，可以声明如下

public static Comparator getComparator(){

class MyComparator implements Comparator{

@Override

public int compare(Object o1, Object o2){ return 0; }

}

return new MyComparator();

}

Comparator com = getComparator();//Comparator com = new MyComparator();

com.compare(new Person(), new Person());

public static Comparator getComparator1(){

//匿名内部类

Comparator com = new Comparator(){ //匿名内部类实现了接口，new 的是匿名内部类的构造器

@Override

public int compare(Object o1, Object o2){ return 0; }

};

return com;

}

public static Comparator getComparator2(){

return new Comparator(){

@Override

public int compare(Object o1, Object o2){ return 0; }

};

}

一、枚举：jdk 1.5 后出的新特性，可以定义有限数量的可穷举数据集

简而言之，当确定一个类有几个对象时，就使用枚举

1. 自定义枚举类

①私有化构造器

②类的内部创建对象

//自定义枚举类

public class Season1 {

private String seasonName;

private String seasonDesc;

//2. 类的内部创建对象

public static final Season1 SPRING = new Season1("春天", "春眠不觉晓");

public static final Season1 SUMMER = new Season1("夏天", "处处蚊子咬");

public static final Season1 AUTUMN = new Season1("秋天", "秋天叶子黄");

public static final Season1 WINTER = new Season1("冬天", "冬天雪花飘");

//1. 私化构造器

private Season1(String seasonName, String seasonDesc){

this.seasonName = seasonName;

this.seasonDesc = seasonDesc;

}

public String getSeasonName() {

return seasonName;

}

public void setSeasonName(String seasonName) {

this.seasonName = seasonName;

}

public String getSeasonDesc() {

return seasonDesc;

}

public void setSeasonDesc(String seasonDesc) {

this.seasonDesc = seasonDesc;

}

@Override

public String toString() {

return "Season [seasonName=" + seasonName + ", seasonDesc="

+ seasonDesc + "]";

}

}

2. 使用 enum 关键字

public enum Season {

SPRING,

SUMMER,

AUTUMN,

WINTER;

}

3. 枚举类实现接口

public enum Season implements MyInterface{

SPRING{

public void show(){

System.out.println("春天");

}

},

SUMMER{

public void show(){

System.out.println("夏天");

}

},

AUTUMN{

public void show(){

System.out.println("秋天");

}

},

WINTER{

public void show(){

System.out.println("冬天");

}

};

/*@Override

public void show() {

System.out.println("季节");

}

*/

}

一、注解：jdk 1.5 后出的新特性，是一个元数据, 是一个代码级别的说明。

在 Java 中以 "@注解名" 的形式呈现。

String name = "atguigu";

1. JDK 内置的常用注解

* ① @Override : 用于描述方法，说明该方法必须是重写方法

* ② @Deprecated ： 用于注解属性、方法、类。 说明已经过时

* ③ @SuppressWarnings : 用于抑制编译器警告

2. 自定义注解

格式：

public @interface MyAnnotation{

String value() default "atguigu";

}

3. 元注解

* ① @Retention ： 描述注解的生命周期

* ② @Target ： 描述注解可用于修饰哪些程序元素

* ③ @Documented : 随之生成说明文档，但注解的生命周期应为 RUNTIME

* ④ @Inherited ： 描述注解具继承性