java 抽象final_(11)Java学习笔记——面向对象05——final关键字 / 抽象类

final关键字：

final是一个修饰符，可以修饰类，方法，变量

为什么要用final修饰变量？

在程序中如果一个数据是固定的，就给该数据起个名称，而且这个变量名称的值不能变化，所以加上final固定。

final关键字的特点：

1 / final修饰类：final修饰类是最终类，该类不能被继承。

2 / final修饰方法：final修饰的方法，不能被重写。

3 / final修饰变量：final修饰的变量是一个常量，只能赋值一次，不能被重新赋值。

final修饰局部变量的问题：

基本类型：是基本类型的值不能发生改变。

引用类型：是引用类型的地址值不能发生改变，但是该对象堆内存的值是可以改变的。

final修饰变量的初始化时机：

1 / 被final修饰的变量只能赋值一次。

2 / 在构造方法完毕前赋值(非静态的常量)

**常量名所有字母用大写,两个单词间用下横线：MY_PI

**变量名第一个单词首字母小写，后继单词首字母大写：myPi

**函数名第一个单词首字母小写，后继单词首字母大写+()：  myPi( )

——————————————————————————————————————————————————

抽象类

关键字：abstract

格式：

abstract  class  类名 { }

public   abstract   void   方法名()；(抽象方法不能有{ }花括号)

一个没有方法体的方法应该定义为抽象方法，

类中如果有抽象方法，该类必须定义为抽象类。

范例：

abstract class 犬科//抽象功能所在的类也必须用abstract修饰成抽象类

{

abstract void 吼叫();//抽象功能用abstract关键字修饰 ，只有声明，没有方法体(没有{}花括号)

}

class 狗 extends 犬科//继承了父类

{

void 吼叫()//一样的功能声明

{

System.out.println("汪汪");//不一样的功能

}

}

class 狼 extends 犬科//继承了父类

{

void 吼叫()//一样的功能声明

{

System.out.println("嗷嗷");//不一样的功能

}

}

抽象类的特点：

1/方法只有声明，没有实现时，该方法就是抽象方法，需要被abstract修饰。

抽象方法必须定义在抽象类中，该类必须也被abstract修饰

2/抽象类不可以被实例化(不能被new创建对象)。

3/抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化，否则，这个子类还是抽象类。

4/抽象类的子类是一个抽象类。

抽象类的实例化是靠具体的子类实现的，是多态的方式。

抽象类的成员特点：

1 / 成员变量： 既可以是变量，也可以是常量。

2 / 构造方法：有，用于子类访问父类数据的初始化。

3 / 成员方法：即可以是抽象的，也可以是非抽象的方法。

抽象类的成员方法特性：

1/ 抽象方法 ：强制要求子类做的事情。

2/ 非抽象方法：子类继承的事情，提高代码复用性。

抽象类可以不定义抽象方法么？

可以。但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。

抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类。

一个类如果没有抽象方法，可以定义为抽象类，意义在于不让创建对象。只能通过子类去访问。

抽象关键字不可以和哪些关键字共存？

private 不行。抽象方法要被覆盖，私有后无法覆盖。

static    不行，无意义。抽象是没有方法体的，静态可使用类名直接调用，调用无方法体的方法无意义。

final      不行。final修饰的方法不能被覆盖，抽象类需要被子类覆盖。

抽象类和一般类的异同点：

相同点：抽象类和一般类都是用来描述事物的，都在内部定义了成员。

不同点：

1/一般类有足够的信息描述事物。

抽象类描述事物的信息有可能不足。

2/一般类中不能定义抽象方法。

抽象类中可定义抽象方法，同时也可以定义非抽象方法。

3/一般类可以被实例化。

抽象类不可以被实例化。

抽象类一定是个父类么？

是的。因为需要子类覆盖其方法后才可以对子类实例化。

练习01：猫狗案例

/*

猫狗案例

*/

//定义一个Animal的抽象类

abstract class Animal

{

public abstract void eat();//定义抽象方法。抽象方法没有方法体。

public abstract void sleep();

}

//定义一个Cat类，继承抽象类Animal

class Cat extends Animal

{

public void eat()//定义一个实例方法重写抽象类中的抽象方法

{

System.out.println("小猫抓老鼠吃");

}

public void sleep()//定义一个实例方法重写抽象类中的抽象方法

{

System.out.println("小猫躺着睡觉");

}

public void playGame()//定义一个cat类特有方法

{

System.out.println("小猫玩耍");

}

}

//定义一个Dog类，继承抽象类Animal

class Dog extends Animal

{

public void eat()

{

System.out.println("小狗吃骨头");

}

public void sleep()

{

System.out.println("小狗站着睡觉");

}

public void lookHome()

{

System.out.println("小狗看家");

}

}

class AnimalTest_01

{

public static void main(String[] args)

{

Animal c = new Cat();//多态。定义一个cat对象

c.eat();

c.sleep();

Cat c1 = (Cat)c;//向下强转，用来调用Cat类中的特有方法

c1.playGame();

System.out.println("------------------------");

Animal d = new Dog();

d.eat();

d.sleep();

Dog d1 = (Dog)d;

d1.lookHome();

}

}