(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();
}
}