Java学习Day14（第六章）（final,抽象类，接口）

对属性赋值的先后顺序

对属性可以赋值的位置
1.默认初始化
2.显式初始化
3.构造器中初始化
4.有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
5.在代码块中赋值

执行的先后顺序1-2/5-3-4

6.4关键字：final

package atguigu.com;
/*
 * final:最终的
 * 
 * 1.final可以用来修饰的结构，类、方法、变量
 * 
 * 2.final用来修饰一个类:此类就不能被其他类所继承
 *             比如：String类、System类、StringBuffer类
 * 
 * 3.final 用来修饰方法：表明此方法不可以被重写
 *         比如：Object类中getClass();
 * 
 * 
 * 4.final 用来修饰变量：此时的“变量”就称为一个常量
 *         4.1 final修饰一个属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
 *         4.2 final修饰局部变量：
 *             尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参
 *             一旦赋值以后，就只能在方法体内使用形参，但不能进行重新赋值。
 * 
 * static final:用来修饰属性：全局常量
 * 
 * 
 * 
 */
public class FinalTest {
    final int width = 10;
    //public void doWidth(){
    //    width = 20;
    //}

    public static void main(String[] args) {
        int num = 10;
        num = num + 5;

    }
}

final class FinalA{

}

6.5抽象类和抽象方法

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

package atguigu.com;
/*
 * abstract关键字的使用
 * 1.abstract:抽象的
 * 2.abstract可以用来修饰的结构：类、方法
 * 3.abstract修饰类：抽象类
 *         >此类不能实例化
 *         >抽象类中一定有构造器，便于子类对象实例化调用（涉及：子类对象实例化全过程）
 *         >开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
 * 
 * 
 * 4.abstract修饰方法：抽象方法
 *         >抽象方法只有方法的声明，没有方法体
 *         >包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
 *         >若子类重写了父类中的所有的抽象方法后，此子类方可实例化
 *         若子类没有重写父类中的所有的抽象方法后，则此子类也是一个抽象类，需要abstract修饰
 *         
 */
public class AbstractTest {
    public static void main(String[] args) {
        //一旦Person类实例化，就不可实例化
        //Person p1 = new Person();
        //p1.eat();

    }
}



abstract class Person extends Creature{
    String name;
    int age;
    public Person(){

    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public abstract void eat();

    public void walk(){
        System.out.println("人走路");
    }
}

abstract class Student extends Person{
    public Student(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println("学生吃饭");
    }
}

abstract class Creature{
    public abstract void breath();
}

• abstract使用上的注意点：
• 1.abstract不能用来修饰：属性、构造器等结构
• 2.abstract不能用来修饰私有方法、静态方法、final的类，方法

  抽象类的匿名子类

package atguigu.com;
/*
 * 抽象类的匿名子类
 * 
 * 
 */
public class PersonTest {
    public static void main(String[] args) {
        method(new Student());//匿名对象

        Worker worker = new Worker();
        method1(worker);//非匿名类、对象

        method1(new Worker());//非匿名的类匿名的对象
        System.out.println("*********************");
            //创建了一匿名子类的对象，p
            Person p = new Person(){

                @Override
                public void eat() {
                    System.out.println("吃东西");
                }

                @Override
                public void breath() {
                    System.out.println("呼吸");
                }

            };
            method1(p);
            //创建匿名子类的匿名对象
            method1(new Person(){

                @Override
                public void eat() {
                    System.out.println("吃好东西");
                }

                @Override
                public void breath() {
                    System.out.println("好好呼吸新鲜空气");
                }

            });

    }
    public static void method1(Person p){
        p.eat();
        p.breath();
    }
    public static void method(Student s){

    }
}

class Worker extends Person{

    @Override
    public void eat() {

    }

    @Override
    public void breath() {

    }


}

多态的应用：模板方法设计模式（TemplateMethod）

package atguigu.com;
/*
 * 抽象类的应用：模板方法的设计模式
 * 
 * 
 */
public class TemplateTest {
    public static void main(String[] args) {
        SubTemplate t = new SubTemplate();

        t.spendTime();
    }
}

abstract class Template{

    //计算某段代码执行所需要花费的时间
    public void spendTime(){
        long start = System.currentTimeMillis();

        this.code();//不确定的部分,易变的部分

        long end = System.currentTimeMillis();
        System.out.println("花费的时间为： " + (end - start));
    }
    public abstract void code();


}
class SubTemplate extends Template{

    @Override
    public void code() {

        for(int i = 2;i <= 1000;i++){
            boolean isFlag = true;
            for(int j = 2;j <= Math.sqrt(i);j++){
                if(i % j == 0){
                    isFlag = false;
                    break;

                }
            }
            if(isFlag){
                System.out.println(i);
            }
        }
    }

}

6.6接口（interface）

package atguigu2.com;
/*
 * 接口的使用
 * 1.接口使用interface来定义
 * 2.java中，接口和类是并列的两个结构
 * 3.如何定义接口：定义接口中的成员
 * 
 *         3.1 JDK7及以前：只能定义全局常量和抽象方法
 *             >全局常量：public static final的,但是书写时，可以省略不写
 *             >抽象方法：public abstract的
 *             
 *         3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法（略）
 *             
 * 4.接口中不能定义构造器!意味着接口不可以实例化
 * 
 * 5.Java开发中，接口通过让类去实现(implements)的方式来使用
 *     如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
 *     如果实现类没有覆盖接口中的所有抽象方法，则此实现类仍为一个抽象类
 * 
 * 6.Java类可以实现多个接口 ---->弥补了Java单继承性的局限性
 *         格式：class AA extends BB implements CC,DD,EE
 * 
 * 7.接口与接口之间可以继承，而且可以多继承    
 * **************************************
 * 8.接口的具体使用，体现多态性
 * 9.接口，实际上可以看作是一种规范
 * 
 * 面试题：抽象类与接口有哪些异同？    
 */
public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(Flyable.MAX_SPEED);


        Plane plane = new Plane();
        plane.fly();
    }
}
interface Flyable{
    //全局常量
    public static final int MAX_SPEED = 7900;//第一宇宙速度
     int MIN_SPEED = 1;//省略了public static final

    //抽象方法
     public abstract void fly();
     //省略了public abstract
     void stop();
}
interface Attackable{
    void attack();
}
class Plane implements Flyable{
    @Override
    public  void fly(){
        System.out.println("通过引擎起飞");
    }
    @Override
    public void stop() {
        System.out.println("驾驶员减速停止");
    }
}
abstract class Kite implements Flyable{
    @Override
    public void fly() {

    }
    @Override

    public void stop() {    
    }    
}
class Bullet extends Object implements Flyable,Attackable{

    @Override
    public void attack() {
    }
    @Override
    public void fly() {
    }
    @Override
    public void stop() {
    }
}

接口的使用与匿名实现类的对象

package atguigu2.com;
/*
 * 接口的使用
 * 1.接口使用上也满足多态性
 * 2.接口，实际上就是定义了一种规范
 * 3.开发中，体会面向接口编程！
 * 
 * 
 */
public class UsbTest {
    public static void main(String[] args) {

        Computer com = new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        com.transferData(flash);
        //2.创建了接口的非匿名实现类的匿名对象
        com.transferData(new Printer());

        //3.创建接口的非匿名实现类的非匿名对象
        USB phone = new USB(){

            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机结束工作");
            }

        };
        com.transferData(phone);

        //4.创建了接口的匿名实现类的匿名对象

        com.transferData(new USB(){
                @Override
            public void start() {
                System.out.println("mp3开始工作");
            }

            @Override
            public void stop() {
                System.out.println("mp3结束工作");
            }
        });
    }
}

interface USB{
    //常量：定义了长、宽、最大最小传输速度等

    void start();

    void stop();

}
class Computer{
    public void transferData(USB usb){
        usb.start();
        System.out.println("具体的传输数据的细节");
        usb.stop();
    }
}

class Flash implements USB{

    @Override
    public void start() {
        System.out.println("u盘开启工作");
    }

    @Override
    public void stop() {
        System.out.println("u盘结束工作");
    }
}

class Printer implements USB{

    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机停止工作");
    }


}

接口的应用：代理模式

package com.atguigu.java1;
/*
 * 接口的应用：代理模式
 * 
 */
public class NetWorkTest {
    public static void main(String[] args) {
        Server server = new Server();
//        server.browse();
        ProxyServer proxyServer = new ProxyServer(server);

        proxyServer.browse();

    }
}

interface NetWork{

    public void browse();

}

//被代理类
class Server implements NetWork{

    @Override
    public void browse() {
        System.out.println("真实的服务器访问网络");
    }

}
//代理类
class ProxyServer implements NetWork{

    private NetWork work;

    public ProxyServer(NetWork work){
        this.work = work;
    }


    public void check(){
        System.out.println("联网之前的检查工作");
    }

    @Override
    public void browse() {
        check();

        work.browse();

    }

}