------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培训、期待与您交流！ -------