03-面向对象(1)

static关键字

1. static:静态的，可以用来修饰属性、方法、代码块（或初始化块）、内部类

2.static修饰属性（类变量）:

• 由类创建的所有的对象，都共用这一个属性

• 当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static修饰的属性，各个对象各自拥有一套副本）

• 类变量随着类的加载而加载的，而且独一份

• 静态的变量可以直接通过“类.类变量”的形式来调用

• 类变量的加载是要早于对象。所以当有对象以后，可以“对象.类变量”使用。但是"类.实例变量"是不行的。

• 类变量存在于静态域中。

3. static修饰方法（类方法）:
   • 随着类的加载而加载，在内存中也是独一份
   • 可以直接通过“类.类方法”的方式调用
   • .内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法
   • 静态的方法内是不可以有this或super关键字的！
   • 静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构

public class TestCircle {
    public static void main(String[] args) {
        Circle c1 = new Circle();
        Circle c2 = new Circle(2.3);
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(Circle.getTotal());
    }
}

class Circle{
    private double radius;
    private static String info = "我是一个圆";
    private int id;//编号
    private static int init = 1001;//控制每个对象的id
    private static int total = 0;//记录创建了多少个对象
    
    public Circle(){
        this.id = init++;
        total++;
    }
    public Circle(double radius){
        this.radius = radius;
        this.id = init++;
        total++;
    }
    
    
    
    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    public static String getInfo() {
        return info;
    }
    public static void setInfo(String info) {
        Circle.info = info;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public static int getTotal() {
        return total;
    }
    public static void setTotal(int total) {
        Circle.total = total;
    }
    @Override
    public String toString() {
        return "Circle [radius=" + radius + ", id=" + id + "]";
    }
    public static void show(){
        System.out.println(Circle.info);
    }
    
    public void desc(){
        System.out.println(this.info);
    }

}

单例设计模式

解决的问题：如何只让设计的类只能创建一个对象
如何实现：饿汉式 & 懒汉式

1. 饿汉式1

class Bank{
    //1.私有化构造器
    private Bank(){}
    //2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
    //4.要求此对象也为static的
    private static Bank instance = new Bank();
    //3.此公共的方法，必须为static 
    public static Bank getInstance(){
        return instance;    
    }
}

2. 饿汉式2

class Bank{
    //1.私有化构造器
    private Bank(){}
    //2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
    //4.要求此对象也为static的
    private static Bank instance = null;
    static{
        instance  = new Bank(); 
    }
    //3.此公共的方法，必须为static 
    public static Bank getInstance(){
        return instance;    
    }
}

3. 懒汉式

class Bank{
    private Bank(){}
    
    private static Bank instance = null;
    
    public static Bank getInstance(){
        if(instance == null){//可能存在线程安全问题的！
            instance = new Bank();      
        }   
        return instance;
    }
}

main()方法

public static void main(String[] args){
     //方法体     
}

//1.main()是一个方法，是主方法，为程序的入口
//2.权限修饰符：public protected 缺省 private ---面向对象的封装性
//3.对于方法来讲：static final abstract 
//4.方法的返回值：void /  具体的返回值类型（基本的数据类型 & 引用数据类型），方法内部一定要有return
//5.方法名：命名的规则：xxxYyyZzz。给方法命名时，要见名之意
//6.形参列表：同一个方法名不同的形参列表的诸多个方法间构成重载。   形参 & 实参---方法的参数传递机制：值传递
//7.方法体：方法定义的是一种功能，具体的实现由方法体操作。

代码块

1. 代码块：是类的第4个成员
   作用：用来初始化类的属性
   分类：只能用static来修饰。

2. 静态代码块：

   • 里面可以有输出语句
   • 随着类的加载而加载，而且只被加载一次
   • 多个静态代码块之间按照顺序结构执行
   • 静态代码块的执行要早于非静态代码块的执行。
   • 静态的代码块中只能执行静态的结构(类属性，类方法)

3. 非静态代码块：

   • 可以对类的属性(静态的 & 非静态的)进行初始化操作，同时也可以调用本类声明的方法(静态的 & 非静态的)
   • 里面可以有输出语句
   • 一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行
   • 每创建一个类的对象，非静态代码块就加载一次。
   • 非静态代码块的执行要早于构造器

4. 关于属性赋值的操作：

   • 默认的初始化
   • 显式的初始化或代码块初始化(此处两个结构按照顺序执行)
   • 构造器中；
   • 以上是对象的属性初始化的过程------
   • 通过方法对对象的相应属性进行修改

final关键词

final:最终的 ，可以用来修饰类、属性、方法

1. final修饰类：这个类就不能被继承。如：String类、StringBuffer类、System类

2. final修饰方法：不能被重写。如：Object类的getClass()

3. final修饰属性：此属性就是一个常量，一旦初始化后，不可再被赋值。习惯上，常量用大写字符表示
   此常量在哪里赋值：①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。

4. 变量用static final修饰：全局常量。比如：Math 类的PI

class D{
    final int I = 12;
    final double PI;
    final String NAME;

    public void m1(){
        System.out.println(I);
//      I = 10;

    }
    {
        PI = 3.14;
    }
    
    public D(){
        NAME = "DD";
    }
    public D(String name){
        this();
        //NAME = name;
    }
}

抽象 abstract

abstract：抽象的，可以用来修饰类、方法

1. abstract修饰类：抽象类
   • 不可被实例化
   • 抽象类有构造器 (凡是类都有构造器)
   • 抽象方法所在的类，一定是抽象类。
   • 抽象类中可以没有抽象方法。
   • 当我们设计一个类，不需要创建此类的实例时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就行实例化

2.abstract修饰方法：抽象方法
- 格式：没有方法体，包括{}.如：public abstract void eat();
- 抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。
- 若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的

//模板方法设计模式
public class TestTemplate {
    public static void main(String[] args) {
        new SubTemplate().spendTime();
    }
}

abstract class Template {

    public abstract void code();

    public void spendTime() {
        long start = System.currentTimeMillis();

        this.code();

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

class SubTemplate extends Template {
    
    public void code() {
        boolean flag = false;
        for(int i = 2;i <= 10000;i++){
            for(int j = 2;j <= Math.sqrt(i);j++){
                if(i % j == 0){
                    flag = true;
                    break;
                }
            }
            if(!flag){
                System.out.println(i);
            }
            flag = false;
        }
    }
}

接口 interface

接口（interface） 是与类并行的一个概念

1. 接口可以看做是一个特殊的抽象类。是常量与抽象方法的一个集合，不能包含变量、一般的方法。
2. 接口是没有构造器的
3. 接口定义的就是一种功能。此功能可以被类所实现（implements）。
   比如：class CC extends DD implements AA
4. 实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
5. 类可以实现多个接口。----java 中的类的继承是单继承的
6. 接口与接口之间也是继承的关系，而且可以实现多继承

5,6描述的是java中的继承的特点。

7. 接口与具体的实现类之间也存在多态性

工厂方法的设计模板

//接口的应用：工厂方法的设计模式
public class TestFactoryMethod {
    public static void main(String[] args) {
        IWorkFactory i = new StudentWorkFactory();
        i.getWork().doWork();
        
        IWorkFactory i1 = new TeacherWorkFactory();
        i1.getWork().doWork();
    }
}

interface IWorkFactory{
    Work getWork();
}
class StudentWorkFactory implements IWorkFactory{

    @Override
    public Work getWork() {
        return new StudentWork();
    }
    
}
class TeacherWorkFactory implements IWorkFactory{

    @Override
    public Work getWork() {
        return new TeacherWork();
    }
    
}

interface Work{
    void doWork();
}

class StudentWork implements Work{

    @Override
    public void doWork() {
        System.out.println("学生写作业");
    }
    
}
class TeacherWork implements Work{

    @Override
    public void doWork() {
        System.out.println("老师批改作业");
    }
    
}

代理模式

//接口的应用：代理模式（静态代理）
public class TestProxy {
    public static void main(String[] args) {
        Object obj = new ProxyObject();
        obj.action();
    }
}

interface Object{
    void action();
}
//代理类
class ProxyObject implements Object{
    Object obj;
    
    public ProxyObject(){
        System.out.println("代理类创建成功");
        obj = new ObjctImpl();
    }
    
    public void action(){
        System.out.println("代理类开始执行");
        obj.action();
        System.out.println("代理类执行结束");
    }
}
//被代理类
class ObjctImpl implements Object{

    @Override
    public void action() {
        System.out.println("=====被代理类开始执行======");
        System.out.println("=====具体的操作======");
        System.out.println("=====被代理类执行完毕======");
        
    }
    
}