黑马程序员--final，接口，多态，object类

final：最终。作为一个修饰符

1.可以修饰类，变量，函数。

2.被final修饰的类不可以被继承，为了避免被继承，被子类复写功能。在class前面加final

3.被final修饰的方法不可以被复写

4.被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。

当在描述实物时，一些数据的出现值是固定的，为了增强阅读性，都给这些值取个名字，而这些值不需要改变，所以加上final修饰。作为常量：常量的书写规范所以字母都大写，如果由多个单词组成，单词间通过_连接。

5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

目前 修饰 类的修饰符 只有 public 和 final

 

抽象：看不懂。abstract

抽象类的特点：

1.抽象方法一定定义在抽象类中。

2.抽象方法和抽象类都必须被abstract关键字修饰。

3.抽象类不可以用new 创建对象，因为调用抽象方法没意义。

4.抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用，如果子类只覆盖了部分都想方法，那么该子类还是一个抽象类。

 

抽象类和一般类没有太大的不同：

该如何描述事物，就如何描述事物，只不过该事物出现了一些看不懂的东西，这些不确定的部分，也是该事物的功能，需要明确出来，但是无法定义主体。通常通过抽象方法来表示。

 

C

抽象类比一般类多了抽象函数。就是在类中可以定义抽象方法。

抽象类不可以实例化。

抽象类中，可以不定义抽象方法，这样做仅仅是不让该类建立对象。

 

接口：

 

初期理解：可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，该类可以通过接口的形式来表示。

Interface 用于定义接口

Class用于定义类 

接口定义 常量：public static final

 方法：public abstract

记住：接口中的成员都是public的。

接口是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实现实例化。否则，子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式，java支持多实现

 

Java 只有在接口和接口之间 存在多继承

//初次认识接口 interface  实现 implements
class Day7_6 
{
public static void main(String[] args) 
{
Doy d = new Doy();
System.out.println(d.NUM);
System.out.println(Doy.NUM);
System.out.println(Inter.NUM);
}
}
interface Inter
{
public static final int NUM = 8;
public abstract void show(); 
}
class Doy implements Inter
{
public void show()
{

}
} 

多态：可以理解为事物存在的多种体现形态

1.多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接收自己的子类对象。

2.多态的前提

必须是类于类之间有关系，要么继承，要么实现。

通常还有一个前提就是：存在覆盖

3.多态的好处

多态的出现大大的提高了程序的扩展性。

4.多态的弊端

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5.多态的应用

6.多态的出现代码中的特点（多态使用的注意事项）

多态中成员函数的特点：（在这种形式的到时候 如： Fu f = new Zi()；）

A)在编译时期：参阅引用型变量所属的类（父类）中是否有调用的方法。如果有，编译通过，如果没有则编译失败。

B)在运行时期：参阅对象所属的类中是否有调用的方法。

//多态
abstract class Animal
{
abstract void eat();
}
class Cat extends Animal
{
public void eat()
{
System.out.println("Ccat。est");
}
public void catchMoucs()
{
System.out.println("抓老鼠");
}
}


class Dog extends Animal
{
public void eat()
{
System.out.println("dog。est");
}
}


class Pig extends Animal
{
public void eat()
{
System.out.println("pig.eat");
}
}
class Day8_1
{
public static void main(String[] args) 
{
Animal c = new Cat();
c.eat();
//c.catchMoucs();  不能调用是因为 Animal 类中没有此函数 所以不能用 Animal c 来调用 如果想调用catch 方法 直接用cat 建立对象
// Cat d = new Cat();
// d.catchMoucs();
function(new Cat());
function(new Dog());
function(new Pig());
Cat d =(Cat)c;//向下转换
d.catchMoucs();
}
public static void function(Animal a)
{
a.eat();
}
}

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

面试：

在多态中，成员变量的特点：

无论编译和运行时，都参考左边（引用型变量所属的类）。

在多态中，静态成员函数的特点：

无论编译和运行都参考左边。

 

 多态的小应用

//多态的应用 在主板上插 网卡和声卡 PCI 就是一个指标 都符合 
interface PCI
{
public void open();
public void close();
}
class MainBonrd
{
public void run()
{
System.out.println("key bord run...,,,...");
}
public void usePCI(PCI p)//多态的产生 PCI p = new NetCard（）；//接口类引用指向自己的子类对象
{
p.open();
p.close();
}
}
class NetCard implements PCI
{
public void open()
{
System.out.println("netcard ....open");
}
public void close()
{
System.out.println("netcard close");
}
}
class SoundCard implements PCI
{
public void open()
{
System.out.println("soundcard ....open");
}
public void close()
{
System.out.println("soundcard close");
}
}
class Day8_4
{
public static void main(String[] args) 
{
MainBonrd mb = new MainBonrd();
mb.run();
mb.usePCI(new NetCard());
mb.usePCI(new SoundCard());
}
}

Object 系统自带的函数

内部类

内部类访问规则：

1.内部类可以直接访问外部类中的成员，包括私有

之所以可以直接访问外部类的成员，是因为内部类持有了一个外部类的引用，格式 外部命.this

2.外部类要访问内部类，必须建立内部类对象

 

什么都不加 访问6  加this 访问 4  再加外部类的名字 3

访问格式：

当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。

可以直接建立内部类的对象。

格式

 

当内部类在成员位置上，就可以被成员修饰符所修饰

比如private讲内部类在外部类中进行封装

Static：内部类就具备了静态的特性

当内部类被static修饰后，只能直接访问外部类中的static成员 。出现了访问局限