本章概述:
第一部分:抽象
抽象描述
抽象特点
第二部分:接口
接口约定
接口类型
接口多实现
第三部分:内部类
匿名对象
内部类
匿名内部类
方法内的内部类
第一部分:抽象(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、有两种情况可以使用匿名对象,对象中的方法只被调用一次或对象可以作为参数传递,内部类是定义在类中成员或局部位置上的类,当分析事物时,发现事物内部还有事物,就定义内部类。