二、final和static关键字，接口和抽象类-创新互联

fianl关键字的作用

final代表最终的意思，可以修饰成员方法，成员变量，类
十载的盘州网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。成都营销网站建设的优势是能够根据用户设备显示端的尺寸不同，自动调整盘州建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联公司从事“盘州网站设计”,“盘州网站推广”以来，每个客户项目都认真落实执行。

final修饰类、方法、变量的效果

final修饰类：该类不能被继承（不能有子类，但是可以有父类）
final修饰方法：该方法不能被重写
final修饰变量：表明该变量是一个常量，不能再次赋值
- 变量是基本类型,不能改变的是值
- 变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的

举例

1 final修饰类：该类不能被继承

2final修饰方法：该方法不能被重写

3final修饰变量：表明该变量是一个常量，不能再次赋值

变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的

final ArrayList list = new ArrayList();
list.add(1);
list.add(2);
list.add("fdsfds");
//list 保存的是地址 所以添加数据没有问题 地址并没有改变
System.out.println(list);

//下面的代码会改变list的地址 所以不允许
list = new ArrayList();
list = null;

static静态的

static 关键字是静态的意思,是Java中的一个修饰符
static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。

static修饰的特点

被类的所有对象共享
随着类的加载而加载，优先于对象存在
- 对象需要类被加载后，才能创建
可以通过类名调用，也可以通过对象名调用
- 被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

体验练习

public class Student {
    String name;
    int age = 10;
    static String country = "中国";

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void eat() {
        System.out.println("吃肉夹馍");
    }
}

static关键字注意事项

静态方法只能访问静态的成员
非静态方法可以访问静态的成员，也可以访问非静态的成员
静态方法中是没有this关键字

代码

Student类有成员变量name和age 有静态变量country
有成员方法drink有静态的方法eat
eat方法里只能调用静态的成员

public class Student {
    String name;
    int age = 10;
    static String country = "中国";

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }


    public static void eat() {
        System.out.println("吃肉夹馍");
        //System.out.println(this.name);//静态方法里没有this
        //System.out.println(name);//静态方法里不能调用成员 变量
        System.out.println(country);
    }

    public void drink() {
        System.out.println("喝豆浆");
        System.out.println(this.name);//可以调用成员变量 
        System.out.println(country);//可以调用静态变量 
    }
}

子类可以继承父类中的静态成员

注意不能够重写静态方法，如果写了一样的静态方法，只是把父类静态方法隐藏了，并不是重写（可以用Override检查）

如何确定一个属性和方法是否要声明为static 属性：

属性可以被多个对象所共享，不会随着对象的不同而不同
类中的常量也常常声明为static

方法：

操作静态属性的方法，通常设置为static的
具类中的方法，习惯上声明为static的，比如Math，Arrays，Collections

接口

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
Java中接口存在的两个意义
1. 用来定义规范
2. 用来做功能的拓展

接口语法

接口用关键字interface修饰
```
public interface 接口名 {}
```

类实现接口用implements表示

public class 类名 implements 接口名 {}

接口不能实例化
- 我们可以创建接口的实现类对象使用
接口的子类
- 要么重写接口中的所有抽象方法
- 要么子类也是抽象类

接口语法练习代码

1接口 Inter1 有一个抽象方法eat
2实现类 Inter1Impl 实现了接口Inter1，也实现了方法eat
3测试代码注意接口不能实例化

代码

接口 Inter1代码

public interface Inter1 {
    //写一个抽象方法
    public abstract void eat()
}

实现类 Inter1Impl 实现了接口Inter1，也实现了方法eat

public class Inter1Impl implements Inter1{
    @Override
    public void eat() {

    }
}

测试

public class Demo01 {
    public static void main(String[] args) {
        //接口不能创建对象
        //Inter1 i1 = new Inter1();
        
        //用接口的实现类 创建对象
        Inter1Impl i1 = new Inter1Impl();
        i1.eat();
    }
}

接口的成员特点

1 成员变量
- 只能是常量
- 默认修饰符：public static final

public class Demo01 {
    public static void main(String[] args) {

        //用接口直接调用
        System.out.println(Inter1.age);
        //Inter1.age = 20; //不可以修改

    }
}

interface Inter1 {
    public static final int age = 10;
    double PI = 3.1415;//默认有public static final
}

2 构造方法
- 没有，因为接口主要是扩展功能的，而没有具体存在

3 成员方法
- 只能是抽象方法
- 默认修饰符：public abstract
- 关于接口中的方法，jdk8和jdk9中有一些新特性，如下

接口的jdk8、9新增功能

默认方法(Java 8)
静态方法(Java 8)
私有方法(Java 9)

jdk8默认方法

格式

public default 返回值类型 方法名(参数列表) { }

作用
- 解决接口升级的问题
注意事项
- 1默认方法不是抽象方法，可以被继承，可以被重写，重写的时候去掉default关键字
- 2public可以省略，default不能省略
- 3如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

接口代码

接口Inter 有抽象方法 jump，默认方法drink, eat

实现类代码

实现接口Inter 实现jump方法，重写drink方法

测试代码

package com.heima.test4;

public interface Jumping {
    public abstract void jump();

    public default void drink() {
        System.out.println("喝水");
    }

    public default void eat() {
        System.out.println("吃点啥");
    }
}


class Cat implements Jumping {
    @Override
    public void jump() {
        System.out.println("猫跳了5米高");
    }

    @Override
    public void drink() {
        System.out.println("喝豆浆");
    }
}

class Dog implements Jumping {
    @Override
    public void jump() {
        System.out.println("狗跳了2米高");
    }

    @Override
    public void drink() {
        System.out.println("喝可乐");
    }
}


public class Demo02 {
    public static void main(String[] args) {
        new Cat().drink();
        new Dog().drink();
    }
}

一个类可以实现多个接口（多个接口逗号分开）

多个实现的接口中有相同的抽象方法，实现类只实现一次就可以了

多个实现的接口中有相同的默认方法，实现类必须重写这个默认方法，否则报错

接口代码

两个接口中有相同的抽象方法 jump,还有相同的默认方法play

public interface Inter1 {
    void eat();
    void jump();
    public default void play() {
        System.out.println("打王者");
    }
}

public interface Inter2 {

    void drink();

    void jump();

    public default void play() {
        System.out.println("去吃鸡");
    }
}

实现类（实现上面的两个接口）

jump实现一次就好
play方法这时候必须实现，因为两个接口中都有默认方法play

class MyInterImpl implements Inter1, Inter2 {

    @Override
    public void eat() {
        System.out.println("chichichci");
    }

    @Override
    public void drink() {
        System.out.println("heheheheheh");
    }

    @Override
    public void jump() {
        System.out.println("跳 啊跳");
    }

    @Override
    public void play() {
        System.out.println("好好学习");
    }
}

测试

public class Demo02 {
    public static void main(String[] args) {
        MyInterImpl a = new MyInterImpl();
        a.drink();
        a.jump();
        a.play();
    }
}

jdk8静态方法

语法 public static void 方法名() {} public可以省略

静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

接口代码

public interface Inter {
    //静态方法eat
}

测试代码

接口名字调用静态方法
实现类名或者对象不能调用

public class Demo02 {
    public static void main(String[] args) {
        Inter.eat();
        //A.eat(); 实现类无法调用
        //new A().eat();实现类的对象也不能 调用
    }
}

class A implements Inter {

}

interface Inter {
    //静态方法eat 默认是public的
    static void eat() {
        System.out.println("吃");
    }
}

实现类写同名方法的代码

实现类也写一个静态方法eat，这个eat和接口中的无关，属于A这个类

public class Demo02 {
    public static void main(String[] args) {
        Inter.eat();
        A.eat();
    }
}

class A implements Inter {
    static void eat() {
        System.out.println("吃");
    }
}

interface Inter {
    //静态方法eat 默认是public的
    static void eat() {
        System.out.println("吃");
    }
}

jdk9私有方法

接口中的私有方法和类中的定义方式一样，也是只能在接口内部使用
一般在接口内部，多个默认方法或者多个静态方法，有很多共性的代码时，就可以抽取出来放到私有方法中

package com.heima.test6;


public class Demo01 {
    public static void main(String[] args) {
        MyInterImpl myInter = new MyInterImpl();
        myInter.play1();
        myInter.play2();
        myInter.play3();
    }
}

class MyInterImpl implements Inter1 {


}

interface Inter1 {
    private void playall() {
        System.out.println("打王者");
        System.out.println("吃鸡");
        System.out.println("打cf");
    }

    public default void play1() {
        playall();

        System.out.println("睡觉");
        System.out.println("出去浪");
    }

    public default void play2() {
        playall();

        System.out.println("出去浪");
        System.out.println("睡觉");
    }

    public default void play3() {
        playall();

        System.out.println("出去睡觉");
        System.out.println("回来浪");
    }

    //接口中定义的私有静态方法
    private static void check() {
        System.out.println("权限校验 ( 模拟 )");
    }

    public static void open() {
        check();
        System.out.println("open方法执行了");
    }

    public static void close() {
        check();
        System.out.println("close方法执行了");
    }
}

类和接口有同样的方法名

父类Fu和接口Inter1 有同样的方法，子类优先使用继承的父类的方法

接口代码

有一个默认方法 eat

public interface Inter1 {
    public default void eat() {
        System.out.println("吃周黑鸭");
    }
}

类代码

也有一个方法eat

class Fu {
    public void eat() {
        System.out.println("吃北京烤鸭");
    }
}

子类代码继承了类Fu 同时也实现了接口Inter1

//子类 继承了Fu 同时实现了接口Inter1
//父类Fu和接口Inter1 有同样的方法eat，子类优先使用继承的父类的eat
class Zi extends Fu implements Inter1 {

}

测试

public class Test1 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.eat();//吃北京烤鸭
    }
}

接口和接口之间可以继承，并且可以多继承

当继承的多个接口，有相同的默认方法时，子接口必须重写这个方法，如下面案例中的method

接口InterA代码和接口InterB代码

public interface InterA {
    public abstract void showA();

    public default void method(){
        System.out.println("InterA...method方法");
    }
}

public interface InterB {
    public abstract void showB();

    public default void method(){
        System.out.println("InterB...method方法");
    }
}

接口InterC代码

1 接口InterC继承了接口InterA和InterB
2 继承了showA和showB两个抽象方法
3 因为InterA和InterB都有默认方法method，所以InterC必须重写method方法

interface InterC extends InterA, InterB {

    @Override
    default void method() {
        System.out.println("interc...method");
    }
}

测试

类TestA实现接口InterC，必须实现showA和showB方法，同时可以使用InterC里的默认方法method

public class TestInterface {
    public static void main(String[] args) {
        TestA a = new TestA();
        a.showA();
        a.showB();
        a.method();
    }
}

class TestA implements InterC {

    @Override
    public void showA() {
        System.out.println("showAshowAshowAshowA");
    }

    @Override
    public void showB() {
        System.out.println("showBshowBshowBshowBshowB");
    }
}

抽象类和接口区别

语法上
- 1实现 extends implements2构造有构造没有
- 3抽象方法权限修饰 public protected 默认 public
- 4多继承继承一个实现多个
思想上
- 类抽象的是属性和方法接口抽象方法
- 飞机鸟
- 直升机继承飞机肯定不能继承鸟和父类有一种 "是不是" 的关系
- 直升机和啄木鸟都实现了接口FLY，有飞的功能，和接口有一种 "有没有" 的关系

interface FLY{
    void fly();
}

interface Sport{
    void jump();
    void run();
}

abstract class airplane{
    String color;
    int length;
}
class Zhishengji extends airplane implements FLY{
    
}

abstract class bird{
    String color;
    String type;
    void eat();
}
class Zhuomnuniao extends bird implements FLY,Sport{
    
}

接口练习

超市管理系统”，设计三个类：收银员(Cashier)、销售员(Sales)、会计(Accountant)

1). 三类人员都需要有“工作(work)”，而且每个类必须要有自己的工作内容。
2). 收银员(Cashier)、会计(Accountant)都要有“统计(count)”的功能，而且两个类也必须要有自己统计的方式请设计以上的类结构，并编写测试类。

Worker类代码

public abstract class Worker{
    public abstract void work();
}

Finance类代码 ˈfaɪnæns 财政金融

public interface Finance{
    void count();
}

子类代码

class Sales extends Worker{
    public void work(){
        System.out.println("销售产品")
    }
}
class Cashier extends Worker implements Finance{
    @Override
    public void work(){
        System.out.println("收银")
    }
    @Override
    public void count(){
        System.out.println("统计今日金额")
    }
}
class Accountant extends Worker implements Finance{
    @Override
    public void work(){
        System.out.println("计算账单")
    }
    @Override
    public void count(){
        System.out.println("统计公司总金额")
    }
}

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧

标题名称：二、final和static关键字，接口和抽象类-创新互联
本文地址：http://mswzjz.cn/article/dsgogs.html

网站建设知识

二、final和static关键字，接口和抽象类-创新互联

其他资讯