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

快来打我* 2022-05-26 00:49 91阅读 0赞

### 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();

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

下面是项目目录结构  
![这里写图片描述][70]

### 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

目录结构  
![这里写图片描述][70 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 {
    
    }

目录结构  
![这里写图片描述][70 2]

[70]: /images/20220526/a54be209c90b49c0822aa0554aa879be.png
[70 1]: /images/20220526/61277617b6a7404ba0a9d3dc05b56b1b.png
[70 2]: /images/20220526/c784553614654b75bb7b06a084decf8f.png