P391单例模式-P395final关键字-P398抽象类关键字

    package singleTon;//注意先调用的时候，会先调用构造器
    public class SingleTon {
    public static void main(String[] args) {
        //通过方法可以获取对象
        Daughter instance = Daughter.getInstance();
        System.out.println(instance.getName());
        Daughter instance2 = Daughter.getInstance();
        //静态相关的时候，只会加载一次，instance和instance2是一个对象
        System.out.println(instance==instance2);//输出true
    }
}
class Daughter{
    private String name;
    private static Daughter d=new Daughter("女儿lucy");
    //饿汉模式，类加载的时候就创建了，饿汉可能创建没有使用
    // 1.构造器私有
    //2.在类中创建一个对象(为了能在静态方法中调用d对象，需要修饰为static)
    //3.提供一个公共方法(静态)

public static Daughter getInstance(){
        return d;
    }
    private  Daughter(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
package singleTon;
​
public class SingleTon {
    public static void main(String[] args) {
        //通过方法可以获取对象
      //  System.out.println(Bf.n1);//不会调用构造器，只输出99
        Bf instance = Bf.getInstance();
        System.out.println(instance);
        //此时输出 构造器被调用
        //Bf{name='小可爱白古'}
        Bf instance1 = Bf.getInstance();
        System.out.println(instance1);
        //输出构造器被调用
        //Bf{name='小可爱白古'}
        //Bf{name='小可爱白古'}
        //意思是对象是一个，只有当用户调用对象的时候才创建对象，下次调用返回上次对象
        System.out.println(instance==instance1);//输出true
    }
}
class Bf{
    private String name;
    private static Bf b;
    //饿汉模式，类加载的时候就创建了
    // 1.构造器私有
    //2.在类中创建一个对象(为了能在静态方法中调用b对象，需要修饰为static)
    //3.提供一个public的static方法,可以返回一个Cat对象
    public static int n1=99;
    public static Bf getInstance(){
        if(b==null){//如果没有创建对象
           b= new Bf("小可爱白古");
        }
        return b;
    }
    private  Bf (String name) {
        System.out.println("构造器被调用");
        this.name = name;
    }
    @Override
    public String toString() {
        return "Bf{" +
                "name='" + name + '\'' +
                '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
​

P392饿汉和懒汉的区别

 

package com.yueeu;
​
public class Final {
    public static void main(String[] args) {
        //new C().Rate_get=0.99;
        // (cannot assign a value to final variable Rate_get
        }
}
final class A{//不能被继承（1）
}
class B{
    public final void hi(){ }//如果要求不能被子类重写（2）//可以继承但不能重写
}
class D extends B{
   // @Override
   // public void hi() {
       // System.out.println("重写了");
    //}
}
class C{//不希望类的某个属性的值被修改，可以用final修饰
    // public final double Rate_get=0.8;//(3)
}
class E{
    public void cry(){
       final double num=2.2;//当不希望某个局部变量被修改，可以用final修饰(3)
       // num=3.3;
    }
}

P395final关键字细节

package com.yueeu;
​
public class Final {
    public static void main(String[] args) {
    }
}
class C{
     public final double Rate_get=0.8;//1.定义时,而且必须给值
    private final double Rate_get1;
    private final double Rate_get2;
    public static final double a=0.1;//静态属性只能在（1）和（2）静态代码块
    public static final double a1;//因为静态属性在类加载的时候已经存在了
    public C(){
        Rate_get1=0.8;//2.构造器中
    }
    {
        Rate_get2=0.7;//3.在代码块中
    }
    static {
        a1=0.2;//(2)
    }
}
​

（5）已经不能继承就不会重写

 

（7）

package com.yueeu;
​
public class Final {
    public static void main(String[] args) {
        System.out.println(A.num); //输出1111
    }
}
class A{
    public final static int num=1111;//static，final前后无区别
    static{
        System.out.println("静态代码块被执行");
    }
}
​
P397final练习

package com.yueeu;
​
public class Final {
    public static void main(String[] args) {
        System.out.println("面积="+new Circle(5.0).getarea());
    }
}
class Circle{
    private double radius;
    private final double PI=3.14;//定义
    private final double P1;
    private final double P2;
    public Circle(double radius){
        this.radius=radius;
        P1=3.1;//构造器
    }
    {
        P2=3.2;//代码块
    }
    public double getarea(){
​
        return PI*radius*radius;
    }
}

P398抽象类

public class Final {
    public static void main(String[] args) {
    }
}
abstract class Animal{
    private String name;
    public Animal(String name) {
        this.name = name;
    }//父类方法的不确定性，将把它设计为抽象方法
   // public void eat(){//所谓抽象方法就是指没有实现的方法
        //就是指没有方法体
      //  System.out.println("不知道该animal吃什么");
   // }//当该类出现抽象方法，需要将该类声明为抽象类
    //一般来说抽象类会被继承，由子类来继承该方法
    public abstract void eat();
}

1

 

 

public class Final {
    public static void main(String[] args) {
       // new A()//抽象类不能被实例化
        //抽象类可以没有抽象方法，但抽象方法必须属于抽象类
        //abstract只能修饰方法和类；
    }
}
abstract class A{
    private String name;
    public A(String name) {
        this.name = name;
    }
    public abstract void eat();
}

abstract class A{
    public abstract void eat();
}
abstract class C extends A{ }
        //或者
class B extends A{
    @Override
    public void eat(){//相等于子类B实现父类A的抽象方法
        //所谓实现方法就是有方法体
    }
}

 

P401抽象类的练习

public class Final {
    public static void main(String[] args) {
       new Ma("mama",11,222,99).work();
    }
}
class Ma extends Em{
    private double bound;
​
    public Ma(String name, int id, double salary, double bound) {
        super(name, id, salary);
        this.bound = bound;
    }
    @Override
    public void work(){
        System.out.println("经理"+getName()+"工作中");
    }
}
abstract class Em{
    private String name;
    private int id;
    private double salary;
    public abstract void work();
    public Em(String name, int id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }
    public String getName() {
        return name;
    }
}