面向对象-static、代码块、final、抽象类

1.

package atguiug_oop_day11;

public class CircleTest {
    public static void main(String[] args) {
        Circle c1 = new Circle();
        Circle c2 = new Circle();

        System.out.println(c1.getId());
        System.out.println(c2.getId());
    }

}

class Circle{

    private double radius;
    private int id;

    //默认id
    public Circle(){
        id = init++; //因为共享，所以每个实例化对象之后都会init++，init的值会变，
        total++;          // 乜有static的话，init每次初始化为1001，那么所有的id都为1001.
    }

    private static int total;
    private static int init = 1001; //static声明的属性被所有对象共享

    public double findArea(){
        return Math.PI * radius * radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

2.代码块

代码块用于初始化类和对象，如果有修饰的话只能用static，加上static为静态代码块，不加为非静态

静态代码块：

        ①内部可以有输出语句

        ②随着类的加载而执行，而且只执行一次

        ③如果一个类中使用了多个静态代码块，则按照声明的先后顺序执行

        ④静态代码块的执行优先于非静态代码块的执行

        ⑤只能调用静态的属性或方法

非静态代码块

        ①内部可以有输出语句

        ②随着对象的创建而执行，每创建一个对象就执行一次，可以在创建对象时对对象的属性进行初始化

        ③如果一个类中使用了多个非静态代码块，则按照声明的先后顺序执行

        ④可以调用静态和非静态的属性或方法

给属性赋值的顺序

        ①默认初始化

        ②显式初始化/在代码块中赋值（看谁写在前面）

        ③构造器中初始化

        ④创建对象，通过对象.属性或者对象.方法赋值

由父及子，静态先行

3.finnal

        3.1 final修饰类：此类不能被其他类所继承，比如：String、System、StringBuffer

        3.2 final修饰方法：此方法不能再被重写，比如：Object类中的getClass()

        3.3  static final用来修饰属性：全局常量 不能变了

        3.4  final修饰变量：此时的变量就称为是一个常量

        3.5  final修饰属性：可以考虑赋值的位置：显式初始化，代码块中初始化、构造器中初始化

        3.6  final修饰局部变量：尤其是用final修饰形参时，表明此形参是一个常量，当调用此方法时，给常量形参赋实参，一旦赋值就只能在方法体内使用此形参，但不能重新赋值

        3.7 static final：用来修饰属性：全局常量；  修饰方法：方法不能调 类直接调。 

4.abstract

可以用于修饰：类（抽象类）、方法（抽象方法）

abstract修饰类：

        ①此类不能实例化（也就是不能创建这个类的对象

        ②虽然自己不能实例化，但是子类会调用父类的构造器，所以抽象类中一定有构造器

abstract修饰方法

        ① 抽象方法只有方法的声明没有方法体，所在的类一定是抽象类。因为如果类不是抽象的，那这个类就可以造对象，可以造对象就可以调用。反之抽象类中可以没有抽象方法。

        ② 若子类重写了子类重写了父类所有的抽象方法才能实例化，如果没有全部重写，那么子类也是抽象类，也需要用abstract修饰

        ③ abstract不能用来修饰私有方法、静态方法、final关键字修饰的方法、final关键字修饰的类

因为如果两个方法都是static，不认为两个方法是重写或者覆盖，所以abstract用来修饰静态方法，就无法重写

        ④abstrct不能修饰属性 构造器等结构

4.抽象的应用

模板方法设计模式。在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤在父类中写好，某些易变的和不确定的部分可以抽象出来给子类实现。

5.代码：

Emplotyee父类

package atguiug_oop_day11.Test03;

public abstract class Employee {

    private String name;
    private int id;
    private double salary;

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

    public Employee() {
        super();
    }
    
    public abstract void work();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

子类Manager类

package atguiug_oop_day11.Test03;

 public  class Manager extends Employee{

     private double bonus;

     public Manager(double bonus) {
         super();
         this.bonus = bonus;
     }

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

    public void work(){
        System.out.println("每天工作8小时，有奖金" + getBonus());
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
}

CommonEmployee子类

package atguiug_oop_day11.Test03;

public class CommonEmployee extends Employee{

    public CommonEmployee(String name, int id, double salary) {
        super(name, id, salary);
    }

    public void work(){
        System.out.println("每天工作10小时，无奖金" );
    }
}

Test测试

package atguiug_oop_day11.Test03;

public class EmployeeTest {
    public static void main(String[] args) {
        CommonEmployee c1 = new CommonEmployee("tom",1001,3000);
        c1.work();

        Manager m1 = new Manager("tony",1000,30000,2000);
        m1.work();

    }
}

6.抽象类的匿名子类对象

Person

package atguiug_oop_day11.Test04;

public abstract class Person {

    public abstract void eat();
    public abstract void speak();
}

Student

package atguiug_oop_day11.Test04;

public class Student extends Person {
    @Override
    public void eat() {

    }

    @Override
    public void speak() {

    }
}

Test

package atguiug_oop_day11.Test04;

public class PersonTest {

    //创建子类的匿名对象
    Person p1 = new Person() {
        @Override
        public void eat() {

        }

        @Override
        public void speak() {

        }
    };
}

7.模板方法设计模式

package atguiug_oop_day11.Test05;

public class TemplateTest {
    public static void main(String[] args) {
        Template t1 = new plate();
        t1.spendtime();
    }
}

abstract class Template{

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

        code();//不确定的部分、易变的部分

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

class plate extends Template{

    @Override
    public void code() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

8.java8中接口新特性

JDK8：除了全局常量和抽象方法，还可以定义静态方法和默认方法（default关键字修饰）

1.接口中定义的静态方法只能通过接口来调用，接口.方法。

2.通过实现类的对象，可以调用接口中的默认方法，对象.方法。如果实现类重写了接口中的默认方法，调用时仍然调用的是重写以后的方法

3.如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，子类在没有重写此方法的情况下调用的是父类中的方法——类优先原则（重写就是调用子类自己的）

4.如果实现类实现了多个接口，而这个多个接口中定义了同名同参数的默认方法，在实现类没有重写方法的情况下会报”接口冲突“错误，此时需要重写。

5.如何在子类（或者实现类）调用父类、接口中被重写的方法，接口.super.方法

        super.method()

        接口.super.method()

9.内部类

1.Java允许将一个类A声明在另一个类B中，A为内部类，B为外部类

2.内部类的分类：成员内部类、局部内部类（方法内，代码块内，构造器内）

3.成员内部类

        作为外部类的成员：可以调用外部类的结构，可以被static修饰
        作为一个类：可以定义属性、方法、构造器，可以用final、abstract修饰，可以被继承

4.需要关注的问题：

        如何实例化成员内部类的对象：外部类Person，静态内部类Brain，非静态内部类Lungs

        静态成员内部类：new 外部类.内部类()

Person.Brain brain=new Person.Brain();

        非静态成员内部类：先造对象，对象.new 内部类()

Person p=new Person();
p.Lungs lungs=p.new Lungs();

        如何在成员内部类中区分调用外部类的结构

                形参直接调，所在类的用this.结构，外部类的用外部类.this.结构

        成员内部类和局部内部类在编译以后都会生成字节码文件

                成员内部类：外部类$内部类名.class

                局部内部类：外部类$数字 内部类名.class

        在局部内部类的方法中，如果调用局部内部类所在的方法中的局部变量，该局部变量必须用final关键字修饰(JAVA8之后可以不写出来，但仍然还是final的)

public void Person(){
    int num=10;
    class AA{//局部内部类
        public void show(){//局部内部类的方法
            num=20;//试图修改会报错
            System.out.println(num);//调用局部内部类所在的方法中的局部变量
        }
    }
}

        开发中局部内部类的使用

                常用的局部内部类：

//方式一
public Comparable getCompareble(){
    class MyComparable implements Comparable{//局部内部类
        @Override
        public int compareTo(Object o){
            return 0;
        }
    }
    return new MyComparable();
}
//方式二
public Comparable getCompareble(){
    return new Comparable(){
        @Override
        public int CompareTo(Object o){
            return 0;
        }
    };
}

10.关键字

static可以用来修饰：属性、方法、代码块、内部类

final关键字可以用来修饰：类、方法、变量（属性和局部变量）

abstract可以用于修饰：类、方法