final关键字

• final用于声明属性,方法和类,可以修饰类,修饰字段,修饰方法,修饰局部变量,修饰形参

• 属性:定义就必须直接赋值或者在构造方法中进行赋值,并且后期不能修改,

• 修饰修饰类,最终类,不能被继承,不能被定义为抽象类或者接口

• 修饰字段,必须显示初始化,不能被修改,一般final与static同时修饰某个字段,所有字母都大写,表示final常量

• 修饰方法:bueng子类不能被覆盖 能被子类继承

• 修饰局部变量, 一旦初始化就不能再修改, 注意final修饰引用类型变量, 是指这个引用类型变量不能再指向其他对象,可以修饰它的属性值

• 修饰方法形参, 在方法体中不能修改final形参的值

final属性赋值:

–在声明时同时赋值,往往与static一起使用

final static int Num = 10;

package com.nie.day5.demo06;

public class Filal {
    
    //用于声明方法和类
    //final修饰常量,常量值不能变,利用static 修饰 节省空间
    final static int Num = 10;
    final int a = 100;


    public final void eat() {
    
        System.out.println("你好");
    }

    //定义就必须直接赋值或者在构造方法中进行中进行赋值,后期不能修改
    public void num(int a) {
    
//       this.a=1000;
        System.out.println(a);
    }


    //在方法参数前加final关键字,防止数据在方法题中被修改.
    public void num1(final int b) {
    
//        b=11;
    }
}

抽象类

为什么定义抽象类?

• 如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类

• 抽象类除了不能实例化对象之外,类的其他功能依然存在,名成变量,成员方法和构造方法的访问方式和普通类一样.

---

如何定义抽象类

• 用abstract修饰的类就是抽象类,如果某个类中包含抽象方法,那么这个类就必须定义抽象类.

---

为什么定义抽象方法:

当一个类的某个操作无法具体实现时,这个操作可以定义为抽象方法,使用abstract修饰方法, 只有方法的声明, 没有方法体

• 抽象方法时一种特殊的方法:他只有声明,而没有具体的实现
• 抽象方法必须用abstract关键字进行修饰

---

如何使用抽象类

• 抽象类一般作为其他类的父类存在,
• 子类继承了抽象类,子类需要重写抽象类中所有的抽象方法,如果没有重写所有的抽象方法子类也需要为定义抽象方法

注意:

抽象类中不一定含有抽象方法

1. 抽象类可以有成员属性和非抽象方法

2. 抽象类不能被实例化,但可以有构造函数.因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象

3. 抽象类不能创建对象:抽象类只能做基类,表示一种继承关系.

4. 构造方法和静态方法不可以用abstract,

---

abstract与final不共存

• 因为abstract不能实例bai化（没有构造方法），du需要有子类zhi来实现，而final为“最终的”，修饰类时表示不能被继承既没有子类，这两个就矛盾了。
  但是呢，一个abstract类里面可以有final关键字存在，前提是这个final修饰的方法必须在abstract类中已经实现，作用是继承它的子类不能重写这个方法

---

[访问权限] abstract class 类名 {
    
		成员列表
	}

public abstract class Shapes {
    
	public abstract void draw();
}

public abstract class Shapes {
    
	public void draw(){
    
         //具体代码
       }
}

然后我们定义个抽象类

抽象类无法被直接实例化，我们可以让子类继承然后实例化子类

然后我们实例化子类

接口

接口的基本概念:

Java中只支单继承,如果向定义一些功能,想让一个子类都能继承实现,提供接口,这样我们就可以用一个子类去实现多个接口.**.可以理解为接口时特殊的抽象类.**这种抽象类中只包含常量和方法的定义,没有变量和方法的实现.

接口设计时候:关系实现类有何做哟个,不关心内部细节,面向接口的约定而不考虑接口的具体实现.

接口的定义:

public interface Animal1 {
    
    //所有属性默认为: public static final
    void eat1();

    //所有方法都是：public abstract
    void foo();
}

• 定义接口: interface

  [访问修饰符]  interface  接口名称  [extends 其他的接口名1,….其他的接口名n] {
         	
          // 声明常量
         // 抽象方法
   }
  

• 接口使用 :implements

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

• 结合继承：

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

接口的特性:接口不能被实例化,实现类必须重写接口的所有方法,实现类可以实现多个接口,接口中的变量都是静态.

接口一

/**
 * 本质上说接口就是一个抽象类,
 * 抽象类中只包含常量和方法的定义,
 * 没有变量和方法的实现
 */
public interface animal extends Animal1 {
    
    //所有属性默认为 public static final
    // public static final int age=10;
    //变量必须赋值
    int age = 10;

    //默认的为public  abstract
    //抽象方法访问时必须进行重写
    void eat();

    public abstract void test();

    //jdk8后接口可以使用默认方法,和静态方法
    //比抽象方法更加灵活,根据功能方法进行选择
    public default void test1() {
      //被子类重写
        System.out.println("默认方法");
    }

    public static void test2() {
    //通过类名访问4
        System.out.println("静态方法");
    }
}

接口二

public interface Animal1 {
    
    //所有属性默认为: public static final
    void eat1();

    //所有方法都是：public abstract
    void foo();
}

接口三

public interface Animal2 {
    
    void  test3();
}

类

//定义为抽象类  或者
//重写抽象方法

/**
 * 一个类可以实现多个接口,
 * <p>
 * 一个类可以实现继承一个类
 * 但是可以实现多个接口
 */
public class Dog implements animal, Animal1, Animal2 {
    

    //抽象方法访问时必须进行重写
    @Override
    public void eat() {
    
        System.out.println("抽象方法\t吃");
    }

    @Override
    public void test() {
    
        System.out.println("抽象方法测试");
    }

    @Override
    public void eat1() {
    
    }

    @Override
    public void foo() {
    
    }

    @Override
    public void test3() {
    
    }
}

测试

public class Test {
    
    public static void main(String[] args) {
    
        Dog dog =new Dog();
        dog.eat();
        dog.test();
        dog.test1();//默认方法//
        animal.test2();//静态方法
    }
}

接口的特性:

• 接口是特殊的抽象类,当声明一个接口的时候必须要声明abstract关键字
• 接口中每一个方法也是隐式抽象的,默认public abstract 。jdk8以后有默认和静态方法 public static 方法, public default方法
• 接口中声明的属性默认为 public static final
• 接口不能被继承,要被实现implements
• 接口不能实例化对象(灭有构造方法),但是可以声明对象的引用(多态性)
• 有接口多有多态。多态的条件（子类重写父类方法，继承，父类引用指向子类对象）因为接口中有抽象方法，所以必须要重写，实现（implements）可以理解为在接口环境下继承（extends）的另一个名字
• 多个类可以使用一个接口
• 一个类可以实现多个接口,但只能继承一个类
• 一个类可以继承多个接口,使用关键字extends，可以继承多个接口，使用 逗号 分割
• 在类实现接口的时候,类要实现接口的所有方法,或者类必须设置为抽象类
• 接口体现的是is-a的关系

接口的好处

• 快速增强子类功能,符合面向对象的思想
• 可扩展性强,当需要增强原有类的功能不需要修改原有类的代码,只需要增加接口.

接口和抽象类的区别:

区别

• 抽象类可以构造方法,接口不可以
• 抽象类可以有普通成员变量,抽象类不行
• 抽象类有非抽象的普通方法,而接口中所有的方法必须是抽象的(jdk8以后有默认和静态方法)
• 抽象类中的抽象方法访问类型可以是public ，protected和默认类型,但接口中的抽象方法只能是public类型的
• 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义静态常量。

不同点:

1. 意义不同

   • 抽象类是对事物更高层级的抽象
   • 接口是对功能的封装

2. 定义方式不同

   • 抽象类用 abstract class定义
   • 接口用interface定义

3. 内容不同

   • 抽象类中除了抽象方法外,还可以定义构造方法等普通类中定义的所有成员

   • 接口除了抽象方法等这四个内容外, 不能定义构造方法等内容

     public abstract修饰, 接口中还可以定义public static final常量 , public static 方法, public default方法

4. 使用方式不同

   • 抽象类需要被子类extends继承
   • 接口需要被实现类implements实现

5. 类只支持单继承, 接口支持多继承

6. 应用场景不同

   • 一般情况下, 对类进行功能的扩展,优先选择接口
   • 除了扩展功能外, 还需要保存不同的数据,只能选择抽象类;
   • 抽象类的抽象方法需要子类重写,
   • 抽象类还可以约束所有的子类都具有相同的功能.

相同点:

​ 1)都可以定义抽象方法

​ 2)都不能实例化对象,创建对象

​ 3)定义的抽象方法都需要被重写

​ 4)都可以定义public static方法, public static final常量