2021-07-21

instanceof 运算符：用来判断某个对象是否属于某一个类或者接口，如果属于返回true 否则返回false（判断是否是不是子类或者本类）

继承 封装 多态
多态：一个事物的多种形态（继承、重写）
1.父类的引用指向子类的对象
2.继承
3.方法的重写

好处：扩展能力强，简化代码，可读性强、
test.java
public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
            Bus bus=new Bus();
            bus.go();
            Taxi taxi=new Taxi();
            taxi.go();
//            以上这不叫做多态，因为已经被写死了
            
            Car c1=new Rocket();//    父类的引用指向子类的对象
            c1.go();
//            Car c2=new Taxi();
//            Car c3=new Metro();

    }

}
父类car.java
package com.neusoft.test2;

public class Car {
public void go(){
    
    
}
}
子类rocket.java
public class Rocket extends Car{
public  void go(){
    
    System.out.println("一秒到火车站");
}
}

工厂设计模式思路(这里拿汽车工厂举例，我们需要汽车类，汽车又分为好几种对象，工厂模式就需要工厂类，再有测试test)
首先，汽车工厂生产汽车，肯定每种汽车都有自己生产的方法，工厂来生产汽车，就一定可以生产所有汽车
这里定义两种汽车作为汽车大类的子类，分别为Benz，BMW，他们有自己的生产方法，去重写汽车大类的生产方法
public class Benz extends Car{
    public void product(){
        System.out.println("奔驰汽车正在生产。。。。。。。。。。");
        
    }
}
public class BMW extends Car{
public void product(){
    
    System.out.println("宝马汽车正在生产。。。。。。。。。");
}
}
汽车大类的方法car
public class Car {
public void product(){
    
}
}
汽车工厂生产汽车CarFactory
public class CarFactory{
public void productCar(Car car)
{
car.product;//运行时多态
}
}
最后使用test去进行测试,首先实例化工厂对象，比如我们要生产benz和bmw两种汽车就需要他们的零件所以也需要实例化这两个对象
接着进行传值
CarFactory carfactory=new CarFactory();
Benz benz=new Benz();//或者写成Car c1=new Benz()也可以，这样下面就可以传c1的值了;
Bmw bmw=new Bmw();
carfactory.productCar(benz)；
carfactory.productCar（bmw）;//编译时多态

运行时（继承）多态和编译时（方法重载）多态

static  关键字 静态
修饰：成员变量，成员方法，代码片（一块代码，一片代码，就是用{}括起来的代码）

代码片运行先于构造方法

静态代码片只执行一次
static{
        
        System.out.println("这就是代码片");
        
    }

在类被加载的时候，在内存中，有static，类加载器会对其特殊处理，在内存中有一个专门空间叫静态区域，会把static修饰的放在里面。
静态区域里面的只分配一次内存，只开辟一次空间。
静态方法就想到共享
student.java
public class Student {
     static String name;
    public static void func(){
        
    }
    }
Test.java
public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
Student s1=new Student();
Student s2=new Student();

Student.name="张三";
s1.age=20;//对象变量
Student.name="李四";//类变量，静态变量，只修饰全局变量
System.out.println(Student.name);
System.out.println(Student.name);
Student s3=new Student();
System.out.println(Student.name);

    }
}
类变量，静态成员变量，只修饰全局变量，用static的变量没有必要做成封装。封装一般都是非静态的数据，
方法也跟上面的一样，也可以是静态的，也可以直接用 类.方法名调用
静态方法只能直接访问静态变量，
非静态方法可以直接访问静态变量和静态资源
public class Student {
//     static
    String name;
     int age;
     static int count=0;
    public static void func(){
//        System.out.println(age);
        System.out.println(count);
    }
    public  void func2(){
        System.out.println(age);
        System.out.println(count);
    }
    
    static{
        
        System.out.println("这就是代码片");
        
    }
    public Student(){
        count++;
        System.out.println("构造方法");
    }
    }
test.java
public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
Student s1=new Student();
Student s2=new Student();
Student s3=new Student();
System.out.println(Student.count);//用在计算一共有多少学生
Student.func();
s1.func2();
//Student.name="张三";
//s1.age=20;//对象变量
//Student.name="李四";//静态变量，类变量，只修饰全局变量
//System.out.println(Student.name);
//System.out.println(Student.name);
//
//System.out.println(Student.name);
    }

}

单例模式
单例模式（singleton）是保证一个类仅有一个实例，并提供一个访问它的全局访问点，
单例模式要点包括：
1.某个类只能有一个实例
2.它必须自行创建这个实例
3.必须自行向整个系统提供这个实例 单例模式实现方式为
4.拥有一个私有构造方法
5.提供一个自身静态私有的成员变量
6.提供一个公有的静态方法
student.java
public class Student {

    private static Student student=new Student();//创建本类静态实例
    
    private Student(){}//构造方法私有化
    
    public static Student getstudent(){
        return student;
    }
    
}
test.java
public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
//        Student s1=new Student();
        Student s1=Student.getstudent();
        Student s2=Student.getstudent();
        System.out.println(s1==s2);
    }

}

final关键字：最终 终态
修饰：类，方法，变量

常量：恒定不变的数据就是常量，用final修饰的变量就是常量
int num=100；（变量）
常量在声明的同时必须要进行初始化
常量的值只能使用不能重新改写
常量所有字母必须全大写

final修饰方法不能被修改如子类继承父类，父类中的有final修饰的方法，子类就不能重写

final修饰类就不能被继承

public static final double PI=3.14;//加static节省空间（每一个对象都开辟一个空间，但是改写不了这个值），

抽象：

抽象类：用abstract 修饰的类就是抽象类，抽象类和普通类没有区别，抽象类比普通化更抽象，
抽象类不能具体化（实例化），抽象类一般都用在继承上，一般的抽象类都加在父类上，在父类上使用抽象类不影响继承
抽象类中不一定含有抽象方法；抽象类可以继承抽象类

不想有任何具体事例和具体实例化操作，构造方法是为了初始化属性存在。没有对象是构造方法调用不了，不能说没有构造方法

抽象方法：用abstract 修饰的方法就是抽象方法
方法由方法的声明和具体实现构成（大括号分界线）
public abstract void test();只有方法的声明，没有方法的实现。抽象方法都靠继承和方法重写来实现的

含有抽象方法的类必须是抽象类，子类必须重写父类的抽象方法
public abstract class Car {
public  abstract void go();
}

public abstract class A {
    public static final double PI=3.14;
    public abstract void test();
}