java语言入门 （三）抽象类和接口 （4）

1.0 知识目标

1.0 掌握抽象类和抽象方法的定义形式
2.0 了解抽象类与继承的必然关系
3.0 掌握接口定义中成员的特点
4.0 掌握接口实现的具体要求
5.0* 掌握内嵌类的定义和使用特点

抽象类刚接触的人觉得没什么卵用，深入学习后自然就知道有什么卵用了

2.0 抽象类和抽象方法

1.0 抽象类的定义形式

用 abstract 关键字修饰

//下面这个就是抽象类，用abstract关键字标识
// 不可以呗实例化，只能够继承，并且抽象方法要在各个子类中实现
abstract class student{
    成员变量定义
    方法(){};
    abstract  方法();//这就是抽象方法
    //这是具体的抽象方法写法，没有大括号啥的，可以有形参
    //抽象方法不定义方法体，只会在继承这个方法的子类中实现
    abstract  void setName();
    }

下面看个例子

//这是抽象类
package b;

public abstract class AbstractTest {
    int theLong;
    int theWidth;
    public abstract void sayLong();
    abstract void sayWidth();

}

//这是抽象类的一个实现
package b;

public class Test extends AbstractTest {

    @Override
    public void sayLong() {
        System.out.println("这个长度是"+theLong);

    }

    @Override
    void sayWidth() {
        System.out.println("这个长度是"+theWidth);

    }

}

//这是另一个实现 也就是子类
package b;

public class Test1 extends AbstractTest {

    @Override
    public void sayLong() {
        System.out.println("哦  这样啊 sayLong");

    }

    @Override
    void sayWidth() {
        System.out.println("哦   sayWidth");

    }

}

//下面是测试类
package b;

public class Test2 {
    public static void main(String[] args) {
        Test test = new Test();
        test.theLong = 10;
        test.theWidth= 1;
        test.sayLong();
        test.sayWidth();
        //还可以用父类变量存放子类对象的引用，例如

        AbstractTest abstractTest = new Test();
        AbstractTest abstractTest1 = new Test1();
        abstractTest.theLong = 101;
        abstractTest.theWidth= 11;
        abstractTest.sayLong();
        abstractTest.sayWidth();

        abstractTest1.sayLong();
        abstractTest1.sayWidth();

    }
}

结果：
这个长度是10
这个长度是1
这个长度是101
这个长度是11
哦  这样啊 sayLong
哦   sayWidth

其他不多说，
AbstractTest abstractTest = new Test();
AbstractTest abstractTest1 = new Test1();

这里用父类变量去存放对象的引用，实际上就是用父类对象去访问具体的子类方法，这种也叫运行时的多态

下面是项目目录结构

3.0 接口

1.0 还是接口的定义形式

[public] abstract interface  接口名  [extends 父接口的列表多个用逗号隔开]{
    [public][static][final]类型  变量名  =  常量值;
    [public] [abstract] 返回值  函数名(参数列表) [throw 异常列表];
}
/*
    1.0 []里的内容是可有可无的
    2.0 接口具有继承性，一个接口可以继承多个接口  用逗号分隔//这里注意  java不能单继承是针对类的
    3.0 接口中的所有常量都是静态常量  默认修饰是  public static final
    4.0 接口中所有方法的修饰符都是public  static
    5.0 接口是抽象类的一种
*/

2.0 接口的实现

1. 一个类可以实现多个接口，中间用逗号隔开，用implement来实现接口
2. 接口里的默认方法是public的抽象方法，实现的时候要在方法显示的加public
3. 如果实现接口时候没有实现a所有的方法，则会提示错误

接着看例子

//父接口1
package c;

public interface Animal{
    int head = 1;//可有可无  默认类型是静态常量 public的

    void eatFood();//这个默认的作用域是public

    public void walk();

}
//父接口2
package c;

public interface Thing {
    void setHeight();
}
//接口1
package c;

public interface Bird extends Animal, Thing {
    void Fly();
}
//实现接口
package c;

public class Imp implements Bird {

    @Override
    public void eatFood() {
        System.out.println("public void eatFood(");

    }

    @Override
    public void walk() {
        System.out.println("public void walk()");

    }

    @Override
    public void setHeight() {
        System.out.println("public void setHeight()");

    }

    @Override
    public void Fly() {
        System.out.println("public void Fly()");

    }

    public static void main(String[] args) {
        Imp imp = new Imp();
        imp.eatFood();
        imp.Fly();
        imp.setHeight();
        imp.walk()
        ;
        System.out.println(imp.head);

    }

}


结果
public void eatFood(
public void Fly()
public void setHeight()
public void walk()
1

目录结构

这个接口啥的看的很清楚 就不多bb了

这里接口类型的变量，也可以用来做实现类对象的引用

public static void main(String[] args) {
        Bird imp = new Imp();
        imp.eatFood();
        imp.Fly();
        imp.setHeight();
        imp.walk()
        ;
        System.out.println(imp.head);

    }

---

总结一下接口和抽象类的区别

1 接口里只能包含抽象方法，静态方法和默认方法，抽象类则完全可以包含普通方法。

2 接口里只能定义静态常量，不能定义普通成员变量，抽象类里则既可以定义普通成员变量，也可以定义静态常量。

3 接口不能包含构造器，抽象类可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。

4 接口里不能包含初始化块，但抽象类里完全可以包含初始化块。

5 一个类最多只能有一个直接父类，包括抽象类，但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承不足。

4.0 内嵌类 （嵌套类）

1.0 静态内嵌类

package d;

public class StaticInnerClass {
    void outerMethod(){
        System.out.println("这是外部类的方法");
    }

    public static class inner{
        public void innerMethod(){
            System.out.println("实例方法  内嵌类");

        }
        public static void innerMethod1(){
            System.out.println("静态类只能访问静态的东西");
        }
    }

    public static void main(String[] args) {
        StaticInnerClass.inner.innerMethod1();//直接访问静态内嵌类的静态方法
        new StaticInnerClass.inner().innerMethod();//对象访问成员方法
        }
}

2.0 成员内嵌类

package d;

public class StaticInnerClass {
    void outerMethod(){
        inner name = new inner();
        name.innerMethod();
    }

    public  class inner{
        public void innerMethod(){
            System.out.println("实例方法  内嵌类");

        }

    }

    public static void main(String[] args) {

        StaticInnerClass class1 = new StaticInnerClass();
        class1.outerMethod();//对象访问成员方法
        }
}

3.0 方法中的内嵌类

package d;

public class StaticInnerClass {
    void outerMethod(){
          class inner{
            public void innerMethod(){
                System.out.println("实例方法  内嵌类");

            }

        }
          new inner().innerMethod();
    }



    public static void main(String[] args) {

        StaticInnerClass class1 = new StaticInnerClass();
        class1.outerMethod();//对象访问成员方法
        }
}

4.0 匿名内嵌类

package d;


public class StaticInnerClass {
    void outerMethod()
    {
        new inner()//这里会报错  需要编写一个接口
        {
            public void innerMethod()
            {
                System.out.println("实例方法  内嵌类");                
            }

        }.innerMethod();  
    }



    public static void main(String[] args) {

        StaticInnerClass class1 = new StaticInnerClass();
        class1.outerMethod();//对象访问成员方法
        }
}


package d;

public interface inner {

}

目录结构