黑马程序员——面向对象（四）

黑马程序员——面向对象

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

一、抽象类

当多个类中出现相同的功能，但是功能主体不同，这是可以进行向上抽取。这时，只抽取功能定义，而不是抽取功能主体。

抽象类的特点：

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

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

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

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

Abstract class Animal{

Abstract void eat();

Abstract void move();

}

Class Cat extends Animal{

Public void eat(){

System.out.println(“吃鱼”);

}

Public void move(){

System.out.println(“走”);

}

 

}

Class Dog extends Animal{

Public void eat(){

System.out.println(“吃肉”);

}

Public void move(){

System.out.println(“跑”);

}

 

}

Public static void main(String[] args){

Animal c=new Cat();

c.eat();

}

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

抽象类比一般类多了个抽象函数。就是再累中可以定义抽象方法。抽象类不可以实例化。

特殊：

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

二、接口

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

Class 用于定义类

Interface 用于定义接口

格式：interface{}

接口的成员修饰符是固定的。

成员常量：public static final

成员函数：public abstract

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

接口中的成员都是public的

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

接口可以被类多实现。

interface Inter{

public static final int NUM=3;

public abstract show();

}

interface Inter1{

public abstract method();

}

 

class Test implement Inter ，Inter1{

public void show(){}

public abstract method(){}

}

Public static void main(String[] args){

Test t=new Test();

System.out.println(t.NUM);

System.out.println(Test.NUM);

System.out.println(Inter.NUM);

 

}

接口的特点

接口是对外暴露的规则，是程序的功能扩展。接口可以用来多实现。类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。接口与接口之间可以有继承关系。

class Sporter{

void play();

}

interface Study{

 

} 

interface Person extends Study{

 

} 

 

class Student extends Sporter implements Person{

} 

三、内部类

/*内部类的访问规则；

 * 1、内部类可以直接访问外部类中的成员，包括私有。之所以可以戒指访问外部类中的成员，

 * 是因为内部类中持有了一外部类的引用，格式 外部类名.this

 * 2、外部类要访问内部类，必须建立内部类对象。

 * 访问格式：

 * 1.当内部类定义在外部类成员位置上，而且非私有，可以在外部其他类中可以直接建立内部类对象。

 * 格式：  外部类名.内部类名 变量名=外部类对象.内部类对象

 *      outer.inner in =new outer().new inner();

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

 * 比如， private:将内部类在外部类中进行封装。

 *       static：内部类就具备了static的特性

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

 *       

 *       在外部其他类中，如何直接访问static内部类呢？

 *       outer.inner.function();

 *       

 *      注意：当内部类中定义了静态成员，该内部类必须是静态的。

 *      当外部类中的静态方法访问内部类是，内部类也不许是静态的 

 *      

 *     

 *      */

 

/*class outer {

int x=3;

class inner{//内部类

int x=4;

void function(){ 

int x=6;

System.out.println("inner:"+x);//x:6    this.x:4     outer.this.x:3

}

}

void method(){

inner in=new inner();

in.function();

}

}

class F2{

public static void main(String[] args){

outer out=new outer();

out.method();

//直接访问内部类的成员

//outer.inner in =new outer().new inner();

//in.function();

}

}*/

 

/*当描述事物时，事物的内部还有事物，该事物用内部类来描述

*      因为内部内事物在使用外部事物的内容。

*/

 

/*class body{

private class heart{

}

public void show(){

}

}*/

/*匿名内部类：

 * 1、匿名内部类其实就是内部类的简写格式。

    2、定义匿名内部类的前提：

    内部内必须是继承一个类或者实现接口

    3、匿名内部类格式：new 父类或接口（）{定义子类内容}

    4.其实匿名内部类就是一个匿名子类对象。

    5.匿名内部类中定义的方法最好不超过3个。

    */

/*abstract class abc{

abstract void show();

}

class Outer {

int x=3;

class Inner extends abc{//内部类

void show(){ 

System.out.println("show:"+x);

}

}

void method(){

//new Inner().show();

new abc(){

void show(){

System.out.println("show:"+x);

}

}.show();

}

}*/