JAVA随笔

JAVA随笔

---

反射
四种类加载器不同的class文件由不同的类来加载,大致分为四种所以类加载器也分为四种

1. BootStrapClassLoader -- (启动类)根类加载器。 加载 核心类库里面的类 java.lang包 ..
2. PlatformClassLoader -- 平台类加载器。 也是加载核心类库里面的一些类，但是这些类 大部分都与模块二有关。
3. AppClassLoader -- 系统类加载器。 加载的是 自己编写的类。
4. 自定义类加载器 -- 比如 加载 网络环境下的类。

 static 五个特点：

1. 　　共享：Static是静态的，随着类加载而加载，
2. 　　类名：使用类名调用，也可以使用对象调用，推荐使用类名调用
3. 　　先后人：被Static修饰的在类加载时就进行加载，是先人，后创建的对象是后人，后人可以使用先人的东西，先人不能使用后人的东西
4. 　　this：static是随着类加载而加载，不能有this，

　　　　　　this是谁调用，tis就指向谁，在这里没有对象调用，所以不能使用this

　　　　　　与this类比的是super，super是调用父类，有参构造和无参构造的第一句话都有调用super  ，只是不写出来，如果一个父类没有无参构造，那么他的子类也不能创建对象，在不更改　　代码的　　情况下，除非传入参数使用父类的有参构造

　　5.　　一次：static修饰的东西在内存中只执行一次

代码块：

1. 　　main方法中的代码块可以看做整体按序使用
2. 　　类中方法外的代码块，总是在构造方法的第一局执行
3. 　　静态代码块是在类加载的时候就开始加载进方法区的静态区

继承：

　　类中的赋值语句其实是在类中定义一个变量，然后赋值语句类似于在静态代码块中赋值(贤哥视频中99%的程序员都会犯得错误)

　　

public class persion
    int a = 10；
public  persion(){
    System.out.println(a);
}

执行顺序

public class persion
    int a;
    {
        a=10;
    }
public  persion(){
    
    System.out.println(a);
}
    
public class persion
    int a;
public  persion(){
    a = 10;
    System.out.println(a);
}

　　java不支持多继承，接口也可以继承；java可以多级继承

　　继承是父类不能调用子类的方法和属性，多态时（父类引用指向子类对象）父类可以调用子类重写的父类方法

　　多级继承时，如果有同名的方法优先使用最近的方法

　　如果一个类继承了一个父类同时实现了一个接口，如果这个父类和接口有同名的方法，子类重写方法并使用自己重写的方法

重写 和 重载：

　　重写：子类继承父类，重写父类的方法，类继承接口 ，重写接口里面的所有方法

　　重载：同一个方法，传入不同的参数，所产生的不同的运算结果。

　　可变参和重载的关系：可变参是一种特殊的重载。

　　重写的注意事项：注意方法的权限是不是可以被重写

案例1：不报错
    class Fu {
        private void show(){
            System.out.println("fu");
        }
    }
    class Zi extends Fu {
        public void show(){  // 不会编译报错  都说了 私有方法不能重写了 为什么还不编译报错呢？？
            System.out.println("zi"); //  因为 父类里面有一个show，但是 子类继承的时候 看不到那个show，所以子类根本不知道父类有show， 自己随便写一个自己的方法名字叫show怎么了啊。
        }
    }    

案例2：// 写一个 会报错的。
    class Fu {
        private void show(){
            System.out.println("fu");
        }
    }
    class Zi extends Fu {
        //@Override  //编译报错  ，因为@Override 关键字表达的意思是 这个关键字下面的方法 是重写的父类的方法。  但实际上 不是重写 所以就报错了。
        public void show(){ 
            System.out.println("zi"); 
        }
    }

案例3：
    //A包下
        public class Person {
            void method(){

            }
        }
    //B包下
        public class Student extends Person {
            public void method(){ // 不会编译报错

            }

        }
案例4：
    //A包下
        public class Person {
            void method(){

            }
        }
    //B包下
        public class Student extends Person {
            @Override //编译报错
            public void method(){ 

            }

        }

　　静态方法不能被重写

　　方法重写时，子类的方法权限要大于父类的权限

权限修饰符：

　　private : 给自己准备的

　　默认的 ：给自己家准备的。

　　protected ： 给自己家准备的， 同时也给你在远方的儿子准备的。

　　public ： 给世界准备的。

设计模式：总共有23这种设计模式，掌握的有单例设计模式，（多例设计模式可以用枚举），静态工厂设计模式等

　　　在静态工厂设计模式中：用户只需要关心自己想要什么类型的产品对象，而对产品对象的创建过程无须关心，全部交给工厂来做，降低了用户与产品类的耦合，也便于对产品的类型进行扩展。

public class JavaStudent {
    //public Notepad note = new Notepad();
    //public Idea note = new Idea();
    public Tools note = ToolsFactory.getTools();
}

public class ToolsFactory { // 静态工厂设计模式
    public static Tools getTools(){
        return new Idea();
    }
}
public interface Tools {
    public void practice();
}
public class Notepad implements Tools{
    public void practice(){
        System.out.println("使用记事本 练习代码");
    }
}
public class Idea implements Tools{
    public void practice(){
        System.out.println("使用idea 练习代码");
    }
}
public class Demo {
    public static void main(String[] args) {
        JavaStudent js = new JavaStudent();
        js.note.practice();

    }
}

//抽象产品角色
public interface Car{
    public void drive();
}

//具体产品角色
public class Benz implements Car{
    public void drive() {
        System.out.println("Driving Benz ");
    }
}
public class Bmw implements Car{
    public void drive() {
        System.out.println("Driving Bmw ");
    }
}

public class Audi implements Car{
    public void drive() {
        System.out.println("Driving Audi ");
    }
}

//工厂类角色
public class Driver {
    //工厂方法.注意 返回类型为抽象产品角色
    public static Car driverCar(String s) throws Exception {
        //判断逻辑,返回具体的产品角色给 Client
        if (s.equalsIgnoreCase("Benz"))
            return new Benz();
        else if (s.equalsIgnoreCase("Bmw"))
            return new Bmw();
        else if (s.equalsIgnoreCase("Audi"))
            return new Audi();
        else throw new Exception();

    }
}

//暴发户
public class Magnate {
    public static void main(String[] args) {
        try {
            //告诉司机我今天坐奔驰
            Car car = Driver.driverCar("benz");
            //下命令:开车
            car.drive();
        } catch (Exception e) {

        }
    }
}

 

final：被final修饰的类不能被修饰

　　   被final修饰的方法不能被重写

　　   被final修饰的变量就成为常量，不能够再次被赋值

自定义常量的命名

　　　　硬性要求： 字母和数字$_ 不能是关键字 不能是数字开头

　　　　软件要求： ​ 大驼峰： 类名 接口名 ​

　　　　　　　　　  小驼峰：方法名 变量名 ​

　　　　　　　　　  峡谷先锋： 常量名 JAVA_HOME

变量：

　　局部变量：定义在局部位置的变量，使用之前必须先赋值，赋值之后不能再次赋值，变量前面默认有final修饰

　　成员变量：定义在类内方法外的变量是成员变量，成员变量可以在定义时直接进行赋值，但是赋值语句实际上是分开的，赋值语句在代码块中在构造方法的

　　　　　　代码块在super之后执行，静态代码块在加载的时候就执行

多态：

　　多态提高了代码的复用性，降低了代码的耦合

　　父类不能调用子类的特有的方法

　　私有的方法，静态的方法，子类写同名方法的时候不是重写

 抽象类：

　　抽象类重点在不能创建对象，有anstract修饰的类叫做抽象类，抽象类不能创建对象，抽象类的子类继承抽象类时要重写里面的所有抽象方法，选择性重写里面的方法

　　抽象类不是用来调用的，是用来让别人重写的，抽象类不一定有抽象方法，有抽象方法的一定是抽象类并且不能创建对象。

　　static 和 abstract 不能同时出现，final 和 abstract也不能同时出现

 接口：

　　接口是一种数据类型，接口不能创建对象，类和接口是实现关系，并且可以多实现（一个类可以实现多个接口），接口和接口之间是继承关系，接口继承可以多继承，

　　子类实现接口必须重写里面的所有的抽象方法

　　接口中的成员变量全都是常量，前面有默认的修饰符public static final

　　接口的作用是可以接耦合

　　USB解耦合的效果代码

interface USB {
    void run();
}
class Computer {
    public void open(){
        System.out.println("电脑开机");
    }
    public void close(){
        System.out.println("电脑关机");
    }
    public void useDevice( USB u){
        // USB u = new Mouse();
        u.run();
    }
}
class Mouse implements USB {
    @Override
    public void run() {
        System.out.println("鼠标有左键 右键 运行起来啦");
    }
}
public class ComputerTest {
    public static void main(String[] args) {
        Computer c = new Computer();

        Mouse m = new Mouse();
        c.useDevice(m);
    }
}

接口和抽象类的区别：

　　语法上非常相似

public abstract class Animal {
    //有构造方法  不能创建对象
    public Animal(){}

    // 成员变量  可以有变量也可以有常量
    int a ;
    public static final int B = 20;

    // 有抽象方法
    public void fun(){
    System.out.println("bbb");
}
    // 也可以有 非抽象方法
    public abstract  void show();

    public void method(){
        System.out.println("aa");
    }

}
public interface USB {
    // 没有构造方法 不能创建对象
    
    // 接口中只有常量
    public static final int B = 20;

    // 抽象方法
    void fun();
    // 默认方法
    defualt void show(){
    System.out.println("bbb");
}
}