java -- 抽象类与接口类

一.protected权限修饰符

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

        // protected修饰的属性和方法本包中可以调用。
        // 不同包中的子类也可以访问protected修饰的属性和方法
        Person person = new Person();
    }
}

import com.atguigu.exer.Person;

public class ProtectedTest {
    public static void main(String[] args) {
        Person person = new Person();
        Student stu = new Student();
        stu.demo();
    }
}

// 不同包的子类也可以访问protected修饰的属性和方法
class Student extends Person{
    public void demo() {
        System.out.println(protectedName);
        say();
    }
}

public class Person {
    protected String protectedName;

    protected void say() {
        System.out.println("say");
    }
}

二.abstract抽象类

1.关键字：abstract（面向对象的四大特性：封装性，继承性，多态性，抽象类）

2.abstract可以修饰方法：抽象方法
　　抽象方法没有方法体

3.abstract可以修饰类：抽象类
　　1.抽象方法所在的类必须为抽象类
　　2.抽象类不能被实例化
　　思考：那么抽象类有构造器吗？有-因为子类的实例化过程：必须调用父类的构造器
　　3.抽象类中可以没有抽象方法。可以有非抽象方法
　　4.非抽象子类必须重写抽象父类中的抽象方法。如果非抽象方法的父类重写了抽象方法，那么子类就不用在重写抽象方法

4.abstract不可以和那些关键字一起使用？
　　private，final，static

public class AbstractTest {
    public static void main(String[] args) {
        Book book = new Book();
        book.read();
    }
}

// 创建一个抽象类
abstract class Library{
    // 方法本身就没有实际含义，但是又必须的写因为考虑到多态，所以这样的方法可以声明成抽象方法
     public abstract void read();
}

class Book extends Library{
    public void read() {
        System.out.println("读一本好书，品味一个完整的人生");
    }
}

三.类的成员之一：代码块

格式：{}

说明：
　　1.代码块只能被static修饰

代码块的分类：静态代码块 VS 非静态代码块

静态代码块：
　　1.用来对类中的信息进行初始化
　　2.静态代码块是随着类的加载而加载的，只加载一次
　　3.静态代码块可以有多个，执行顺序从上到下依次执行
　　4.静态代码块中只能 调用类变量和静态方法（因为加载时机不同）
　　5.静态代码块的加载优先于非静态代码块

非静态代码块：
　　1.用来对对象进行初始化
　　2.非静态代码块是随着对象的创建而加载的
　　3.非静态代码的加载优先于构造器
　　4.非静态代码块可以有多个，执行顺序从上到下依次执行
　　 5.非静态代码块中可以调用类变量和静态方法

如果一些是代码只是加载一次，可以考虑放到静态代码块当中

    {
        //    非静态代码块
        System.out.println("{}"+ Name );

    }

    static {
        //静态代码块
        System.out.println("{1}" + age);
    }

四.final关键字

请简述final关键字？
 final修饰的类：不能被继承

final修饰的方法：不能被重写

final修饰的变量：只能被赋值一次，且必须进行初始化（往往修饰的变量作为常量）
final 的赋值方式有三种：显示赋值，代码块赋值，构造器赋值

 *    变量的赋值：1.默认值    2.显示赋值    3.代码块赋值    4.构造器赋值    5.对象名.方法名/对象名.属性
 *
 *    赋值顺序：1 <- 2/3(谁在上，谁先赋值) <- 4 <- 5

例子1

// 设计模板 

public class TemplateMethod {
    public static void main(String[] args) {
        Code code = new Code2();
        code.runTime();
    }
}

abstract class Code{

    public void runTime(){
        // 计算代码开始的时间
        long start = System.currentTimeMillis();

        // 执行需要执行的代码
        runCode();

        // 计算代码结束时间
        long end = System.currentTimeMillis();

        // 计算时间差
        System.out.println("time=" + (end - start));
    }

    public abstract void runCode();
}

class Code2 extends Code{

    public void runCode() {
        for(int i = 1;i < 100;i++){
            if(i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

五.接口类interface

接口在jdk1.8时的新特性：

　　1.接口除了可以有常量和抽象方法，还可以有默认方法和静态方法

　　2.如何调用静态方法：接口名.静态方法名
　　如何调用默认方法：实现类的对象.默认方法名

　　3.类优先原则：一个类的父类和接口中有相同的方法。通过该类的对象调用的该方法是父类中的方法

　　4.一个类中实现了多个接口，如果多个类中有相同的默认方法，那么该类必须重写该方法

　　5.在类中的方法，调用接口中的默认方法：接口名.super.默认方法名

接口：interface

格式：interface 接口名{ }

说明：
　　1.接口和类是并列关系
　　2.接口不能被实例化
　　3.接口中只能有常量和抽象方法（jdk1.8之前）
　　4.接口和接口之间的关系：继承关系，而且是多继承
　　5.类和接口的关系：class 类名 implements 接口，而且可以实现多个接口（Java是单继承多实现）
　　6.接口和类之间的多态性

接口类的用法：
　　1.通过接口类可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系
　　2.通过接口可以指明多个类需要实现的方法，一般用于定义对象的扩张功能
　　3.接口主要用来定义规范。接触耦合关系

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

        Mouse mouse = new Mouse();

        Computer computer = new Computer();
        computer.useMouseBlue(mouse);
        computer.useMouseUsb(mouse);

        // 创建接口的匿名实现类的对象
        USB kb = new USB() {
            @Override
            public void start() {
                // TODO Auto-generated method stub
                System.out.println("键盘正常连接");
            }

            @Override
            public void end() {
                // TODO Auto-generated method stub
                System.out.println("键盘断开连接");
            }
        };

        computer.useMouseUsb(kb);

        // 创建了一个匿名实现类的匿名的对象
        computer.useMouseUsb(new USB() {

            @Override
            public void start() {
                // TODO Auto-generated method stub
                System.out.println("晚上好");
            }

            @Override
            public void end() {
                // TODO Auto-generated method stub
                System.out.println("明天见");
            }

        });

    }
}

class Computer{

    public void useMouseUsb(USB usb) {
        usb.start();
        System.out.println("连接正常");
        usb.end();
    }

    public void useMouseBlue(BlueTooth bt) {
        bt.startBlue();
        System.out.println("蓝牙连接正常");
        bt.endBlue();
    }
}

interface BlueTooth{
    void startBlue();
    void endBlue();
}

interface USB{
    void start(); // 默认会自动添加 public abstract
    void end();
}

class Mouse implements USB,BlueTooth{

    @Override
    public void start() {
        System.out.println("鼠标开始运行了");
    }

    @Override
    public void end() {
        System.out.println("鼠标停止运行了");
    }

    @Override
    public void startBlue() {
        System.out.println("蓝牙开始连接了");
    }

    @Override
    public void endBlue() {
        System.out.println("蓝牙断开连接了");
    }
}

原文地址：https://www.cnblogs.com/jiujiang/p/11613891.html