面向对象（final关键字，接口）

￡神魔★判官ぃ 2023-10-09 23:03 51阅读 0赞

## 一.final关键字 ##

用来声明属性（成员变量），方法和类

### 1.1final属性赋值 ###

*  在声明的同时赋值，往往与static一起使用（使用后在方法区就只有一份）
 *  声明时不赋值，必须在构造方法中逐一赋值
 *  创建每个对象的时候，final属性的值是正确的

### 1.2final修饰 ###

对参数做final修饰：在方法参数前面加final关键字，为了防止数据在方法体中被修改

例：

//final 修饰的类不可以被继承
    public class FinalDemo {
        //final+static 修饰的在方法区是唯一的
        final static int num = 0;
        final String name;
    //每次创建的name都是唯一的
        public FinalDemo(String name) {
            this.name = name;
        }
        //final修饰的方法不可以重写
        public final void first(){
            System.out.println("我就是我，不一样的烟花");
        }
        public static void main(String[] args) {
          FinalDemo finalDemo =  new FinalDemo("小黑子");
            System.out.println("我是"+finalDemo.name);
        }
    }

public class Final1 extends FinalDemo{
    
        public Final1(String name) {
            super(name);
        }
    }

public class Test {
        public static void main(String[] args) {
            FinalDemo finalDemo = new FinalDemo("鸡哥");
            System.out.println("我的名字是"+finalDemo.name);
            finalDemo.first();
            Final1 final1 = new Final1("小红");
            System.out.println("我的名字是"+final1.name);
            final1.first();
        }
    }

结果：![72fc74bb1a544a7089fe7917e5a34772.png][]

## 二.接口 ##

### 2.1接口的定义 ###

接口的定义：使用 interface 关键字用来声明一个接口。

\[访问修饰符\] interface 接口名称 \[extends 其他的接口名1,….其他的接口名n\]

// 声明常量 抽象方法 静态方法 默认方法

### 2.2接口的使用 ###

类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

\[访问修饰符\] class 类名 implements 接口名1，接口名2……\{ \}

结合继承：

\[访问修饰符\] class 类名 extends 父类名 implements 接口名1，接口名2……\{ \}

### 2.3接口的特性 ###

接口的特性：

• 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字

• 接口中方法可以是抽象的,静态的,默认的

• 接口中声明的属性默认为 public static final 的

• 接口不是被类继承了，而是要被类实现

• 接口不能实例化对象

• 与继承关系类似，接口与实现类之间存在多态性

• 一个接口能继承其它多个接口

• 当类实现接口的时候，类要实现接口中所有的抽象方法。否则，类必须声明为抽象的类

例：

public class Animal {
        String name;
        int age;
        public void eat(){
        }
    }
    public interface Run {
         void run();
    }
    public interface Swim {
         void swim();
         public default void test1(){
              //创建默认方法
              System.out.println("默认方法");
         }
         public static void test2(){
              System.out.println("静态方法");
         }
    }
    public class Cat extends Animal implements Run,Swim {
        @Override
        public void run() {
            System.out.println("小猫会跑");
        }
    
        @Override
        public void swim() {
            System.out.println("小猫会游泳");
        }
    }
    public class Cow implements Run {
    
        @Override
        public void run() {
            System.out.println("哞儿~，快跑");
        }
    }
    public class Test {
        public static void main(String[] args) {
            Cat cat = new Cat();
            cat.age=18;
            System.out.println(cat.age);
            cat.name="咪咪";
            System.out.println(cat.name);
            cat.eat();
            cat.run();
            cat.swim();
            Run run = new Cat();
            run.run();
            Swim swim = new Cat();
            swim.swim();
            Swim.test2();
            //静态方法通过接口名访问
            cat.test1();
            //默认方法通过子类创建的对象访问
        }
    }

[72fc74bb1a544a7089fe7917e5a34772.png]: https://img-blog.csdnimg.cn/72fc74bb1a544a7089fe7917e5a34772.png