Java抽象类（abstract）_java abstract类-CSDN博客

本文链接：https://blog.csdn.net/WXxz0/article/details/120498711

Abstract学习

Abstract入门

package com.xz.abstract_;

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

    }
}

abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    //思考:这里eat这里你实现了，其实没有什么意义
    //即: 父类方法不确定性的问题
    //===>考虑将该方法设计为抽象(abstract)方法
    //===> 所谓抽象方法就是没有实现的方法
    //===> 所谓没有实现就是指，没有方法体
    //===>当一个类中存在 抽象方法时，需要将该类声明为abstract类
    //===>一般来说，抽象类会被继承，由其子类来实现抽象方法
//    public void eat(){
//        System.out.println("这是一只动物，但是不知道吃什么...");
//    }
    public abstract void eat();
}

package com.xz.abstract_;

public class AA extends Template{
    public void job() {
        long count = 0;
        for (long i = 1; i <= 800000; i++) {
            count += i;
        }
    }
}

package com.xz.abstract_;

public class BB extends Template {
    public void job() {
        long count = 0;
        for (long i = 1; i <= 80000; i++) {
            count *= i;
        }
    }
}

package com.xz.abstract_;

public abstract class Template {
    public abstract void job();

    public void calTime() {
        //得到开始的时间
        long start = System.currentTimeMillis();
        job();//动态绑定机制
        //得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("运行时间为：" + (end - start));
    }
}

package com.xz.abstract_;

public class TestTemplate {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calTime();

        BB bb = new BB();
        bb.calTime();
    }
}

package com.xz.abstract_;

public class AbstractDetail01 {
    public static void main(String[] args) {
        //抽象类不能被实例化
//        A a = new A();
    }
}

//1)抽象类不能被实例化
abstract class A {
}

//2)抽象类不一定要包含abstract方法。 也就是说抽象类可以没有abstract方法
abstract class B {
}

//3)一旦类包含 了abstract方法,则这个类必须声明为abstract
abstract class C {
    public abstract void say();
}

//4) abstract只能修饰类和方法，不能修饰属性和其它的。
class D{
//    public abstract int n1 = 10;
}

AbstractDetail

package com.xz.abstract_;

public class AbstractDetail01 {
    public static void main(String[] args) {
        //抽象类不能被实例化
//        A a = new A();
    }
}

//1)抽象类不能被实例化
abstract class A {
}

//2)抽象类不一定要包含abstract方法。 也就是说抽象类可以没有abstract方法
abstract class B {
}

//3)一旦类包含 了abstract方法,则这个类必须声明为abstract
abstract class C {
    public abstract void say();
}

//4) abstract只能修饰类和方法，不能修饰属性和其它的。
class D{
//    public abstract int n1 = 10;
}

AbstractExercise

package com.xz.abstract_;

public class AbstractExercise01 {
    public static void main(String[] args) {
        CommonEmployee commonEmployee = new CommonEmployee("jack", "jackie", 5000);
        commonEmployee.work();

        Manager manager = new Manager("xz", "zeaper", 10000, 5000);
        manager.work();
    }
}

abstract class Employee {
    public String name;
    public String id;
    public double sal;

    public Employee() {
    }

    public Employee(String name, String id, double sal) {
        this.name = name;
        this.id = id;
        this.sal = sal;
    }

    public abstract void work();
}

class CommonEmployee extends Employee {
    public CommonEmployee(String name, String id, double sal) {
        super(name, id, sal);
    }

    @Override
    public void work() {
        System.out.println("普通员工" + name + "工作中...");
    }
}

class Manager extends Employee {
    public double bonus;

    public Manager(String name, String id, double sal, double bonus) {
        super(name, id, sal);
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println("经理" + name + "工作中...");

    }
}

CodeBlock学习

CodeBlock入门

package com.xz.codeblock_;

public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie1 = new Movie("你好,李焕英");
        System.out.println("==============");
        Movie movie2 = new Movie("唐探3",30);
        System.out.println("==============");

        Movie movie3 = new Movie("速激9",50,"林诣彬");

    }
}

class Movie {
    private String name;
    private int price;
    private String directer;

    {
        System.out.println("广告开始播放...");
        System.out.println("电影开始播放...");
        System.out.println("电影播放完毕...");
    }

    public Movie(String name) {
        System.out.println("name");
        this.name = name;
    }

    public Movie(String name, int price) {
        System.out.println("name + price");
        this.name = name;
        this.price = price;
    }

    public Movie(String name, int price, String directer) {
        System.out.println("name + price + directer");
        this.name = name;
        this.price = price;
        this.directer = directer;
    }
}

CodeBlockDetail01

package com.xz.codeblock_;

public class CodeBlockDetail {
    public static void main(String[] args) {
        //类 被加载的时候 静态代码块会被执行
        //以下三种情况类会被加载
        //1.创建对象实例时
        //A a = new A();

        //2.创建子类对象实例，父类代码块也会被加载
        //A a1 = new A();

        //3.使用类的静态成员时（静态属性、静态方法）
//        System.out.println(Dog.n1);
        //静态代码块只会被执行 (类只会加载一次)一次
//        System.out.println(Dog.n1);

        //普通代码块 被创建一次 就会就会调用一次
//        DD dd1 = new DD();
//        DD dd2 = new DD();


        //如果只是使用类的静态成员，普通代码块并不会执行
        System.out.println(DD.num);
    }
}

class DD {
    public static int num = 999;

    static {
        System.out.println("DD的静态代码块被执行...");
        System.out.println("=================");
    }

    //在new对象时会被调用，每加载一次就会被执行一次
    //可以这样简单理解：普通代码块是构造器的一种补充机制，构造器没被调用，普通代码块也不会被调用
    {
        System.out.println("DD的普通代码块被执行...");
    }
}

class Dog {
    public static int n1 = 10;

    static {
        System.out.println("Dog的代码块被执行...");
        System.out.println("=================");

    }
}

class A extends B {
    static {
        System.out.println("A的代码块被执行...");
        System.out.println("=================");
    }
}

class B {
    static {
        System.out.println("B的代码块被执行...");
        System.out.println("=================");
    }
}

CodeBlockDetail02

package com.xz.codeblock_;

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        AA aa = new AA();

    }
}

//静态代码块优先级高于普通代码块
//最后执行的才是构造方法
class AA {
    //无参构造器
    public AA() {
        System.out.println("无参构造器被调用...");
    }

    //普通属性的初始化
    private int n2 = getN2();

    {
        System.out.println("普通代码块被执行...");
    }

    private int getN2() {
        System.out.println("getN2被调用...");
        return 200;
    }

    //属性初始化和静态代码块执行优先级一样
    //所以系统会按顺序执行

    //属性初始化
    private static int n1 = getN1();

    //静态代码块
    static {
        System.out.println("静态代码块被执行....");
    }

    public static int getN1() {
        System.out.println("getN1被调用...");
        return 100;
    }
}

Final关键字学习

fianl关键字入门

package com.xz.final_;

public class Final01 {
    public static void main(String[] args) {
        E e = new E();
//        e.TAX_RATE=0.09;

    }
}

//1.不希望被继承，可加final
final class A {
}

//class B extends A{
//}

//2.不希望父类某个方法被子类覆盖/重写
class C {
    public final void say() {
        System.out.println("say()...");
    }
}

//class D extends C {
//    @Override
//    public void say() {
//        super.say();
//    }
//}

//3.不希望某个属性的值被修改
class E {
    public final double TAX_RATE = 0.08;
}

//4.不希望某个局部变量被修改
class F {
    public void hi() {
        final double TAX_RATE = 0.08;
//        TAX_rate = 0.09;
        System.out.println(TAX_RATE);
    }
}

FinalDetail01

package com.xz.final_;

public class FinalDetail {
    public static void main(String[] args) {
        CC cc = new CC();

        EE ee = new EE();
        ee.say();
    }
}

class AA {
    /*
     *  final修饰的常量可赋值的地方
     *  1. 定义时
     *  2. 构造器
     *  3. 代码块
     */

    public final double TAX_RATE1 = 0.08;
    public final double TAX_RATE2;
    public final double TAX_RATE3;

    public AA(double TAX_RATE2) {
        this.TAX_RATE2 = 12.5;
    }

    {
        TAX_RATE3 = 8.8;
    }

}

class BB {
    /*
     *  如果final定义的属性是静态的，则初始化的位置只能是
     *  1. 定义时
     *  2. 静态代码块
     *  不能在构造器中赋值
     */
    public static final double TAX_RATE1 = 0.08;
    public static final double TAX_RATE2;

    static {
        TAX_RATE2 = 8.8;
    }
}

//final类不能继承，但是可以实例化对象
class CC {
}

//如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承
//即  仍然遵守继承的机制
class DD {
    public final void say() {
        System.out.println("say()...");
    }


}

class EE extends DD {

}

FinalDetail02

package com.xz.final_;

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

        //代码块不会被执行
        System.out.println(CCC.rate);

    }
}

//5)一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。
final class AAA {
//    public final void say(){
//        System.out.println("say()...");
//    }
}

//6) final不能修饰构造方法(即构造器)
class BBB {
    public String name;

//    public final BBB(String name) {
//        this.name = name;
//    }
}

//7) final和static往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理
class CCC {
    public final static double rate = 0.08;

    static {
        System.out.println("代码块...");
    }
}

//8)包装类(Integer,Double,Float, Boolean等都是final),String也是final类,不可以被继承。
//class DDD extends String{}