Java基础巩固（main函数的详解、单例设计模式继承、继承、super关键字、重写、instanceof 关键字）

一、main函数的详解：
    
    public ： 公共的。 权限是最大，在任何情况下都可以访问。 private  
        原因： 为了保证让jvm在任何情况下都可以访问到main方法。

    static:  静态。静态可以让jvm调用main函数的时候更加的方便。不需要通过对象调用。
        
    void:  没有返回值。 因为返回的数据是 给 jvm，而jvm使用这个数据是没有意义的。所以就不要了。
    

    main: 函数名。   注意： main并不是关键字,只不过是jvm能识别的一个特殊的函数名而已。
    
    

    arguments ：担心某些程序在启动需要参数。

public static  void main(String[] args) 
	{
		System.out.println("数组的长度："+ args.length);
		for(int i = 0 ; i <args.length ; i++){
			System.out.print(args[i]+",");
		}

		Scanner scanner = new Scanner(System.in);

		
	}

二、单例设计模式

保证一个类在内存中只有一个对象。

模式：模式就是解决 一类 问题的固定步骤 。

模式的概念最早起源于建筑行业....

建房子的步骤都是一样子：
    
    打地基-----> 浇柱子------->盖楼面--------->砌墙--------->封顶---->装修-----入住

软件行业中23种设计模式：

    单例设计模式
    模板设计模式
    装饰者设计模式
    观察者设计模式
    工厂设计模式

单例设计模式的步骤：    


饿汉单例设计模式
    1. 私有化构造函数。
    2. 声明本类的引用类型变量，并且使用该变量指向本类对象。
    3. 提供一个公共静态的方法获取本类的对象。

懒汉单例设计模式：
    1. 私有化构造函数。
    2. 声明本类的引用类型变量，但是不要创建对象，
    3. 提供公共静态 的方法获取本类 的对象，获取之前先判断是否已经创建了本类 对象
    ，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，
    然后再返回。


推荐使用： 饿汉单例设计模式。  因为懒汉单例设计模式会存在线程安全问题，目前还不能保证一类在内存中只有一个对象。

//饿汉单例设计模式 ----> 保证Single在在内存中只有一个对象。
class Single{

	//声明本类的引用类型变量，并且使用该变量指向本类对象
	private static	Single s = new Single();

	//私有化构造函数
	private Single(){}

	//提供一个公共静态的方法获取本类的对象
	public	static  Single getInstance(){
		return s;
	}
}

class Test{
public static Test t=new Test();
private Test{}
public static Test getInstance(){
return t;
}
}
class Test{
public static Test t;
private Test{}
public static Test getInstance(){
if(t==null){
t=new Test();
}
return t;
}
}

//懒汉单例设计模式 ----> 保证Single在在内存中只有一个对象。

class Single2{
	
	//声明本类的引用类型变量，不创建本类的对象
	private static Single2 s;

	//私有化了构造函数
	private Single2(){}

	//
	public static Single2 getInstance(){
		if(s==null){
			s = new Single2();
		}
		return s;
	}
}





class Demo5 
{
	public static void main(String[] args) 
	{
		Single2 s1 = Single2.getInstance();
		Single2 s2 = Single2.getInstance();
		System.out.println("是同一个对象吗？"+ (s1==s2));

	}
}

三、继承

继承是通过关键字extends体现的。

继承的格式：

    class 类名1 extends 类名2{
    
    }


继承要注意的事项：
    1. 千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。
    2. 父类私有的成员不能被继承。
    3. 父类的构造函数不能被继承。

    4. 创建子类对象时默认会先调用父类无参的构造函数。

调用父类 的构造方法是可以初始化从父类继承下去的属性的。

super(name); //指定调用父类一个参数的构造函数。       this(); // 调用本类无参构造方法..

四、super关键字：

super关键字代表了父类空间的引用。

super关键字的 作用：
    1. 子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
    2. 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。

super关键字调用父类构造方法要注意的事项：
    1. 如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上面加上super()语句。
    2. super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。

    3. super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。

super关键字与this关键字的区别：
    1. 代表的事物不一致。
            1. super关键字代表的是父类空间的引用。    
            2. this关键字代表的是所属函数的调用者对象。
    2. 使用前提不一致。
            1. super关键字必须要有继承关系才能使用。
            2. this关键字不需要存在继承关系也可使用。
    3. 调用构造函数的区别：
            1. super关键字是调用父类的构造函数。

            2. this关键字是调用本类的构造函数。

五、重写

重写的前提： 必须要存在继承的关系。

方法的重写: 子父类出了同名的函数，这个我们就称作为方法的重写。

什么是时候要使用方法的重写：父类的功能无法满足子类的需求时。

方法重写要注意的事项：
    1.方法重写时， 方法名与形参列表必须一致。
    2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
    3.方法重写时，子类的返回值类型必须要小于或者 等于父类的返回值类型。
    4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。
            Exception(最坏)
            RuntimeException(小坏)

方法的重载：在一个类中 存在两个或者两个 以上的同名函数,称作为方法重载。

方法重载的要求
    1. 函数名要一致。
    2. 形参列表不一致（形参的个数或形参 的类型不一致）
    3. 与返回值类型无关。

六、instanceof 关键字

instanceof关键字的作用：判断一个对象是否属于指定的类别。

instanceof关键字的使用前提：判断的对象与指定的类别必须要存在继承或者实现的关系。

instanceof关键字的使用格式：
        
        对象  instanceof 类别