final-static-接口-接口与抽象类的区别

1、final## 标题
final修饰的类不可以被继承，是一个最终类，
final修饰的方法是最终的方法，不可以被重写，但可以被继承使用
final修饰的变量不可以被修改值
2、stati## 标题
static可以定义静态的属性，可以通过类共享，被static修饰的是在加载类的时候就被加载到静态区，
static修饰的类，方法，成员变量都可以通过类名直接使用

package com.itheima.demo05static;

/*
    定义每个学生特有的成员(非静态)
        只有一种使用方式:创建对象,访问属性,调用方法
    定义每个学生共享的成员(静态)
        有两种使用方式:
            1.创建对象,访问属性,调用方法(不推荐,占用内存,效率低)
            2.静态的成员属于类,所以我们可以通过类名直接使用
                类名.静态成员变量
                类名.静态的成员方法(参数);
 */
public class Student {
    
    
    //定义非静态的成员变量
    int a = 10;
    //定义静态成员变量
    static int b = 20;

    //定义非静态的成员方法
    public void show01(){
    
    
        System.out.println("Student类的非静态show01方法!");
    }

    //定义静态的成员方法
    public static void show02(){
    
    
        System.out.println("Student类的静态show02方法!");
    }
}

测试类

package com.itheima.demo05static;

public class Demo01Student {
    
    
    public static void main(String[] args) {
    
    
        //创建Student对象
        Student s = new Student();
        System.out.println(s.a);
        System.out.println(s.b);
        s.show01();
        s.show02();
        //静态的成员,通过类名可以直接使用
        System.out.println(Student.b);
        Student.show02();
        Student.b = 200;
        System.out.println(Student.b);

        Demo01Student.method();
        //同一个类中,使用静态的成员,可以省略类名
        method();
    }

    public static void method(){
    
    
        System.out.println("静态的method方法!");
    }
}

3、接口## 标题
接口就是定义一些功能的规范，是一些类的特有属性，谁实现接口，谁就拥有该接口的功能
接口里必须定义抽象方法，因为接口中没有抽象方法的话，接口就没有实际的意义，
接口的格式是interface，接口不能创建对象，
下面是接口的具体使用：

package com.itheima.demo06interface;

/*
    定义使用含有抽象方法的接口(重点)
    抽象方法:没有方法体,被abstract修饰的方法
    定义格式:
        public abstract 返回值类型 方法名(参数);
    注意:
        1.接口中的抽象方法修饰符是可以省略不写的,不写默认也是public abstract
          建议写出,增强阅读性
    -----------------------------
    接口的使用:
    1.接口是不能创建对象使用
    2.可以定义一个实现类,实现(继承)接口,重写接口中的抽象方法,创建实现类对象使用
 */
public interface MyInter {
    
    
    //定义抽象方法
    //public abstract void show01();
    //abstract void show01();
    void show01();

    public abstract int show02();

    public abstract void show03(String s);
}
package com.itheima.demo06interface;

/*
    定义接口的实现类
    使用格式:使用实现类实现接口,重写接口中的抽象方法
        public class 实现类名 implements 接口{
            重写接口中的抽象方法
        }
    注意:
        实现类似于继承,类实现接口,就可以继承接口中所有的非私有方法
 */
public class MyInterImpl implements MyInter{
    
    

    @Override
    public void show01() {
    
    
        System.out.println("实现类重写接口中的show01抽象方法!");
    }

    @Override
    public int show02() {
    
    
        System.out.println("实现类重写接口中的show02抽象方法!");
        return 0;
    }

    @Override
    public void show03(String s) {
    
    
        System.out.println("实现类重写接口中的show03抽象方法!"+s);
    }
}
package com.itheima.demo06interface;

public class Demo01MyInter {
    
    
    public static void main(String[] args) {
    
    
        //'MyInter' is abstract; cannot be instantiated 接口不能创建对象使用
        //MyInter my = new MyInter();

        //创建接口的实现类对象
        MyInterImpl my = new MyInterImpl();
        my.show01();
        my.show02();
        my.show03("张靓颖");

    }
}

类与类之间只能单继承，类与类之间可以多重继承，类可以同时实现多个接口

package com.itheima.demo06interface;

public class Demo01MyInter {
    
    
    public static void main(String[] args) {
    
    
        //'MyInter' is abstract; cannot be instantiated 接口不能创建对象使用
        //MyInter my = new MyInter();

        //创建接口的实现类对象
        MyInterImpl my = new MyInterImpl();
        my.show01();
        my.show02();
        my.show03("张靓颖");

    }
}
package com.itheima.demo09abstractInterface;

//定义含有抽象方法的接口
public interface B {
    
    
    public abstract void b();
    public abstract void show();
}
package com.itheima.demo09abstractInterface;

/*
    接口的多实现:类可以同时实现多个接口
    格式:
        public class 实现类 implements 接口1,接口2,接口3....接口n{
            重写所有接口中的抽象方法
        }
     注意:
        接口中含有抽象方法,实现类需要重写所有接口的抽象方法
        如果接口中有同名的抽象方法,实现类只重写一个就可以了
        不会产生不确定性,抽象方法没有方法体
 */
public class AandBImpl implements A,B{
    
    
    @Override
    public void a() {
    
    
        System.out.println("实现类重写A接口中的抽象a方法!");
    }

    @Override
    public void b() {
    
    
        System.out.println("实现类重写B接口中的抽象b方法!");
    }

    @Override
    public void show() {
    
    
        System.out.println("实现类重写A接口和B接口中的抽象show方法!");
    }
}
package com.itheima.demo09abstractInterface;

public class Demo01 {
    
    
    public static void main(String[] args) {
    
    
        //创建接口的实现类对象使用
        AandBImpl ab = new AandBImpl();
        ab.a();
        ab.b();
        ab.show();
    }
}

抽象类和接口的区别