二、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关键字，接口和抽象类-创新互联
网站URL：http://cqcxhl.com/article/dsgogs.html