Java基础(四)

一、重写和重载的区别?
1 重载发生在同一个类中, 方法名相同, 参数类型/列表个数不同,和方法签名的其他任何关键字无关.
2 重写发生在子类继承父类的关系中, 方法名相同, 参数类型/列表也要相同,权限访问修饰符不能比父类更严格(小);返回值类型必须和父类相同或是父类返回值类型的子类/实现类.声明的异常不能比父类更大。
二、instanceof的作用?
判断某个变量是否为某种类型.
应用场景: 不同的子类拥有不同的行为方法.
当使用父类作为变量引用子类对象的时候,要调用子类独有的方法,要先做
instanceof判断, 再强转回对应的子类调用该子类的独有方法…
如果不判断直接强转,可能会抛出ClassCastException(类型转换异常)
三、try中有return, finally会不会执行
1 必须执行
2 在return的中间执行
3 return的值会在临时空间, 然后去执行finally
4 如果finally中没有新的return, 那么最终返回的还是try里面的值
5 如果finally中有新的return, 那么会覆盖临时空间的值, 最终返回
finally里面的值

四、异常的理解?
一. 结构:
java中异常的基类为
Throwable
Exception
RuntimeException运行时异常：
ClassCastException(类转换异常)
IndexOutOfBoundsException(数组越界异常)
NullPointerException(空指针异常)
ArrayStoreException(数据存储异常，操作数组时类型不一致)
BufferOverflowException(还有IO操作的,缓冲溢出异常)
!Runtime…(CheckedException)检查性异常
Error
错误
指编译错误的代码,内存溢出,硬件故障…等不可抗力错误.
程序自身一般无法修复.

2. 运行时异常RuntimeException
  2.1 该异常在程序运行的时候可能会抛出的异常,该异常jvm不要求一定处理.
  (程序员可以选择处理或不处理)
3. 检查性异常"CheckedException"
  3.1 该异常要求程序员必须处理的异常. 否则编译不通过.
番外: 什么是处理? 处理的意思trycatch或继续往外声明throws

五、throws和throw的含义?
throws声明异常: 告诉调用方,我这个方法可能会抛出(报错)一个这样的异常.
当抛出的异常为检查性异常,那么调用方必须处理,或继续往外声明.

throw抛出异常 程序本来不报错的,手动让它报一个我们指定的异常

六、什么是构造方法
构造方法没有返回值类型, 但是可以有参数(和普通方法一样)
构造方法的名字不能随便取,只能且必须和类名一致.
构造方法是类在被构造为实例的时候调用的
（new Class的时候调用的.）
构造方法如果不写, 默认有一个public的. but如果写了
那么默认的就没有了.
七、访问修饰符有哪些, 区别?
public 自己, 同包, 子类, 其他任意包任意类
protected 自己, 同包, 子类
default/friendly(不写) 自己, 同包
private 自己

八、多态的表现形式有?
1、父类引用指向子类对象
2、方法的重载,在调用的时候,是多态的表现如,System.out.println(?类型);
3、方法的重写,在使用父类变量调用会自动调用子类重写的方法.
4、可变参数…

九、try,catch
1、try中的代码如果正常不报错, 那么catch不会执行.
2、try中如果报错, 那么会从报错的位置直接跳到catch中执行
(该报错位置后面的代码没有机会执行,被跳过了),
catch中可以做一些记录,打印等操作(程序员自己选择).
catch执行完成后,程序不会结束, 而是已经修复好,继续往下执行…
3、catch可以有多个,从上往下匹配, 匹配后,则修复了, 则不会在进入其他同级catch.
若所有的catch都没有匹配到, 那么程序的异常没有被处理,程序就结束了(死亡)
4. try可以单独使用, 也可以和catch使用, 也可以和finally使用
也可以和catch和finally使用
十、抽象类和接口的区别?
1 抽象类有构造器, 接口木有
2 抽象类可以有普通方法和静态方法, 接口木有,接口中只有抽象方法
3 抽象类只能被单继承, 接口可以多实现
4 抽象类可以有普通属性, 接口木有, 接口的属性都为静态常量
5 抽象类可以使用4个访问修饰符, 接口只有public

代码案例积累：

//枚举类型的简单模型！
public enum DogPet {
    labrador("聪明的拉布拉多犬"),
    schnauzer("酷酷的雪娜瑞");
    DogPet(String type){
        this.type = type;
    }
    public final String type;
}

简单的抽象工厂案例

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

public interface Color {
    void fill();
}

public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Inside Blue::fill() method.");
    }
}

public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Inside Red::fill() method.");
    }
}

public abstract class AbstractFactory {
    public abstract Color getColor(String color);
    public abstract Shape getShape(String shape);
}

public class ShapeFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {
       return null;
    }

    @Override
    public Shape getShape(String shapeType) {
        if (shapeType == null){
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")){
            return new Circle();
        }else if (shapeType.equalsIgnoreCase("RECTANGLE")){
            return new Rectangle();
        }else if (shapeType.equalsIgnoreCase("SQUARE")){
            return new Square();
        }
        return null;
    }
}

public class ColorFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {
        if (color == null){
            return null;
        }
        if (color.equalsIgnoreCase("RED")){
            return new Red();
        }else if (color.equalsIgnoreCase("GREEN")){
            return new Green();
        }else if (color.equalsIgnoreCase("BLUE")){
            return new Blue();
        }
        return null;
    }

    @Override
    public Shape getShape(String shape) {
        return null;
    }
}

public class FactoryProducer {
    public static AbstractFactory getFactory(String choice){
        if (choice.equalsIgnoreCase("SHAPE")){
            return new ShapeFactory();
        }else if (choice.equalsIgnoreCase("COLOR")){
            return new ColorFactory();
        }
        return null;
    }
}

public class FactoryPatternDemo {
    public static void main(String[] args) {
        AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
        Shape shape1 = shapeFactory.getShape("CIRCLE");
        shape1.draw();
        Shape shape2 = shapeFactory.getShape("RECTANGLE");
        shape2.draw();
        Shape shape3 = shapeFactory.getShape("SQUARE");
        shape3.draw();
        AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
        Color color1 = colorFactory.getColor("RED");
        color1.fill();
        Color color2 = colorFactory.getColor("GREEN");
        color1.fill();
        Color color3 = colorFactory.getColor("BLUE");
        color1.fill();
    }
}

单例模型之懒汉式

public class Singleton {
    private Singleton(){}
    private static Singleton instance;
    public static Singleton getInstance(){
       synchronized (Singleton.class){
           if (instance == null){
               instance = new Singleton();
           }
           return instance;
       }
    }   //这懒汉式
    public void print(){
        System.out.println("哈哈哈哈这是单例模式！");
    }
}

单例模型之饿汉式

public class Singleton {
    private Singleton(){}
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
       return instance;
    }  //这是饿汉式
 
    public void print(){
        System.out.println("哈哈哈哈这是单例模式！");
    }
}