黑马程序员——java基础（面向对象）抽象、接口、内部类

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

第五章：面向对象（抽象、接口、内部类）

本章概述：

第一部分：抽象

抽象描述

抽象特点

第二部分：接口

接口约定

接口类型

接口多实现

第三部分：内部类

匿名对象

内部类

匿名内部类

方法内的内部类

第一部分：抽象（abstract）

1、抽象类：

在java中，含有抽象方法的类称为抽象类，当子类向上抽取共性方法形成父类后，父类的一个或多个方法所有子类都一定要定义，且子类对该方法的具体实现各不相同时，就没有必要再在父类中进行该方法的具体实现了，那么可以将该父类方法定义成一个抽象方法。将该父类定义成抽象类。

2、抽象的特点：

2.1、有抽象方法的类必须标识成抽象的

2.2、抽象方法一定定义在抽象类中

2.3、抽象方法和抽象类都必须用abstract修饰

2.4、抽象类不可以创建对象，但是有构造函数，用于给子类初始化时调用

2.5、如果子类继承抽象类但没复写其抽象方法，那么该子类还是抽象的

2.6、抽象方法不定义方法主体，让子类定义具体功能

2.7、抽象类中可以不定义抽象方法（不让new对象，也是一种封装形式）

3、抽象示例：

上···代···码······

/*
需求：抽象类
*/

//创建一个类，命名AbstractDemo,继承Abstract（用extends关键字）
class  AbstractDemo extends Abstract
{
//主函数
public static void main(String[] args)
{
//创建子类对象，用父类引用指向子类对象，实现了多态
Abstract abs = new AbstractDemo();

//调用show方法
abs.show();

//调用父类的print方法
abs.print();
}

//复写父类的show方法，因为父类的show方法是public权限的，子类复写父类的方法权限必须不能小于父类方法，所以必须public
public void show()
{
System.out.println("我是子类的show方法");
}
}
abstract class Abstract
{
//抽象方法，没有方法体，非抽象的子类一定要实现该方法
public abstract void show();

//抽象类中可以定义非抽象方法，且可以没有抽象方法
public void print()
{
System.out.println("我是父类的print方法");
}
}

第二部分：接口（interface）

1、当类中方法全是抽象的，那么可以将该类定义成接口，用关键字interface定义

2、定义接口的格式

接口中的成员都有固定修饰符

接口中的成员都是public的

常量：public static final

方法：public abstract

3、接口的特点：

3.1、接口是对外暴露的规则

3.2、接口是程序的功能扩展

3.3、接口可以用来多实现

3.4、类与接口之间是实现关系，而且类可以在继承一个类后实现多个接口

3.5、接口与接口之间可以有继承关系

3.6、接口不可以创建对象，需要被子类实现，子类对抽象方法全部覆盖后，子类才可以实例化

4、示例：

哥们儿代码来···啦！

<pre name="code" class="java"><pre name="code" class="java">/*
需求：接口演示
*/

//创建一个类InterfaceDemo,实现Interface接口，用implements关键字
//一个类可以同时实现单继承和多实现
class  InterfaceDemo extends Abstract implements Interface,Interface2
{
//主函数
public static void main(String[] args)
{
//创建对象
Interface Inte = new InterfaceDemo();

//调用show方法
Inte.show();

//打印父类定义的常量
System.out.println(Inte.num);
}

//复写父类的show方法，因为父类的show方法是public权限的，子类复写父类的方法权限必须不能小于父类方法，所以必须public
public void show()
{
System.out.println("我是show方法");
}
}

//定义一个接口
interface Interface
{
//接口中只有常量，没有变量（默认加public static final）
int num = 3358;

//接口中只能有抽象的方法，接口中的成员格式固定，不写也会默认，也可以显示的写出来
void show();

//方法默认加public abstract，接口中不宜写太多方法，否则扩展性很差

}
//再写一个接口做多实现演示
interface Interface2
{
}

//写一个抽象类做继承、实现演示
abstract class Abstract
{
}

第三部分：内部类

1、匿名对象

1.1、匿名对象，就是没有名字的对象，是对象的简化形式。

1.2、匿名对象的使用场景：

1.2.1当对象的方法仅需要被调用一次时，可以用匿名对象的形式

1.2.2当匿名对象可以作为实际参数进行传递时，可以不用给对象命名

代码演示：

/*
需求：匿名对象的两种用法
*/

//创建类
class  NoName
{
//主函数
public static void main(String[] args)
{
//创建NoName对象，只调用一次show方法
new NoName().show();

//调用demo方法，new一个匿名NoName对象作为参数传递
demo(new NoName());
}

//demo方法，接收一个NoName对象
public static void demo(NoName nn)
{
//方便区分是谁调用了show方法
System.out.println("demo说：");
//调用show方法
nn.show();
}

//show方法，打印语句
public void show()
{
System.out.println("哥们儿来啦！");
}
}

2、内部类

2.1定义在成员或局部的位置的类叫内部类。

2.1内部类的特点：

2.1.1内部类可以直接访问外部类的成员，包括私有修饰的

2.1.2外部类要访问内部类要创建内部类对象，

创建方法：

外部类对象.new 内部类构造函数

2.1.3内部类可以被私有修饰，对内部类进行封装

2.1.4内部类定义在局部位置时，不能访问非静态的局部变量（JDK1.8新特性允许访问了）

代码演示：

//需求：演示内部类访问规则
class InnerClass
{
public static void main(String[] args)
{
//创建外部类对象，通过method方法创建内部类对象，访问内部类成员
Outer out = new Outer();
out.method();

//直接访问内部类中的成员，用外部类对象.内部类对象.内部类方法
Outer.Inner in = new Outer().new Inner();
in.function();
}
}
//定义一个外部类
class Outer
{
private int x = 3;

//在成员的位置上定义一个内部类
class Inner
{
int x = 4;

//内部类的function方法
void function()
{
int x = 6;

//直接访问x访问的是就近的x，即局部的x
System.out.println("x = "+x);
//加上this访问的是内部类成员上的x
System.out.println("x = "+this.x);
//加上Outer.this访问的是外部类上的x
System.out.println("x = "+Outer.this.x);
}
}

//外部类的method方法
void method()
{
//在外部类里面创建内部类对象可以直接创建
Inner in = new Inner();
in.function();
}
}

2.2静态内部类

2.2.1内部类可以被静态修饰，内部类就具备了静态的属性，只能访问外部类的静态成员

2.2.2当内部类中有静态成员时，该内部类必须是静态的

2.2.3当外部类静态成员要访问内部类时，该内部类必须是静态的

代码演示：

//需求：演示静态内部类访问规则
class InnerClass
{
public static void main(String[] args)
{

//直接访问静态内部类中的静态成员
Outer.Inner.function();

//调用外部的静态方法，访问静态内部类
Outer.method();
}
}
//定义一个外部类
class Outer
{
private int x = 3;

//在成员的位置上定义一个静态内部类
static class Inner
{
int x = 4;

//内部类的静态function方法，当内部类中有静态成员时，该内部类必须是静态的
//静态内部类中也可以有非静态方法，但是要new内部类对象才可以访问
static void function()
{
int x = 6;

//直接访问x访问的是就近的x，即局部的x
System.out.println("x = "+x);

//外部类和内部类成员位置上的x不是静态成员，所以静态方法不能访问，下面的语句会出错
//System.out.println("x = "+this.x);
}
}

//外部静态方法调用静态内部类中的静态成员（通通都要是静态的）
static void method()
{
Inner.function();
}
}

2.3匿名内部类

2.3.1匿名内部类必须是继承一个类或实现一个接口

2.3.2匿名内部类是接口的匿名子类对象

2.4、什么时候用内部类：

当分析事物时，发现事物内部还有事物时，就用内部类描述

代码演示：

//需求：演示匿名内部类
class InnerClass
{
public static void main(String[] args)
{
//匿名内部类是类或接口的子类对象

//继承一个类创建匿名内部类
new NoNameInner(){
//复写父类的method方法
void method()
{
System.out.println("this");
}

//调用method方法
}.method();

//实现一个接口创建匿名内部类
new NoNameInner1(){
void method()
{
System.out.println("interfaceNoName");
}
}.method();
}
}
//定义一个类NoNameInner
class NoNameInner
{
//
void method()
{
System.out.println("super");
}
}

//定义一个接口NoNameInner1
interface NoNameInner1
{
void method();
}

本章总结：

1、抽象类是无法实例化对象的类，它是子类向上抽取共性功能时，得到了不需要父类具体实现但子类必须要定义的方法，再将方法定义成抽象方法，而父类具有抽象方法实例化对象是没有意义的，因此也将父类定义成抽象类，抽象类简化了类的书写，增强了程序的扩展性。

2、接口是所有方法都是抽象方法的类型，接口内的成员都具有固定的修饰格式，接口中定义的方法不宜过多，否则会使接口非常臃肿，接口为类提供功能扩展的方式，一个类允许实现多个接口，也允许一个接口被多个类实现。

3、有两种情况可以使用匿名对象，对象中的方法只被调用一次或对象可以作为参数传递，内部类是定义在类中成员或局部位置上的类，当分析事物时，发现事物内部还有事物，就定义内部类。

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------