day09

一、main函数详解

public static void main(String[] args){
   

}

主函数是什么：主函数是一个特殊的函数，作为程序的入口，可以被jvm识别。

主函数的定义：

       public ：代表该函数的访问权限是最大的。

       static ：代表主函数随着类的加载，就已经存在了；静态可以使jvm调用main函数更加方便，不需要通过对象调用。

       void：  主函数没有具体的返回值

       main ： 不是关键字，是一个特殊的单词可以被jvm识别。

       (String[] args) 函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

       主函数的格式是固定的：jvm能够识别

       jvm在调用函数是，传入的是new String[0];

 

二、单例设计模式（设计模式：一些人总结出来用来解决特定问题的固定的解决方案）

1. 解决一个类在内存中只存在一个对象，想要保证对象的唯一。

(1) 为了避免其他程序过多的建立该类对象。禁止其他程序建立该类对象。

(2) 为了其他程序可以访问该类对象，在本类中自定义一个对象。

(3) 方便其他程序对自定义类的对象的访问，对外提供一些访问方式。

 

2.单例设计模式的步骤：

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

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

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

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

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

 

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

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

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

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

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

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

 

三、继承

面向对象的三大特征：
1. 封装
2. 继承
3. 多态.

继承的格式：

class 类名1 extends 类名2{

}

 

继承要注意的事项：
1. 千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。
2. 父类私有的成员不能被继承。
3. 父类的构造函数不能被继承。
4. 创建子类对象时默认会先调用父类无参的构造函数。

 

四、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关键字是调用本类的构造函数。

class Fu{
        
    int x = 10;

    String name;


    public Fu(){
        System.out.println("Fu类无参的构造方法..");
    }

    public Fu(String name){
        this.name = name;
        System.out.println("Fu类带参的构造方法..");
    }


    public void eat(){
        System.out.println("小头爸爸吃番薯..");
    }
}


class Zi extends Fu{
    
    int x = 20; 

    int num;
    
    public Zi(String name,int num){
        super(name); //指定调用了父类带参的 构造方法...
        this(); // 调用本类无参构造方法..
        //super(); //指定调用了父类无参构造方法。。。
        System.out.println("Zi类带参的构造方法..");
    }

    public Zi(){
        System.out.println("Zi类无参的构造方法..");
    }


    public void print(){
        System.out.println("x = " +super.x);
    }

    public void eat(){
        System.out.println("大头儿子吃龙虾..");
    }
}

class Demo9 {

    public static void main(String[] args) 
    {
        Zi z = new Zi("狗娃");

    
    }
}

 

目前的问题：父类的功能无法满足子类的需求。

class Animal{  //大的数据 类型 
}

class Fish extends Animal{  //Fish小 的数据类型。
}


class Fu{

    String name;

    public Fu(String name){
        this.name = name;
    }

    public Animal eat() throws RuntimeException {
        System.out.println(name+"吃番薯...");
        return new Animal();
    }
}


class Zi extends Fu{

    String num;
    
    public Zi(String name){
        super(name);//指定调用 父类带参的构造方法
    }


    //重写父类的eat方法
    public Animal eat() throws Exception{
        System.out.println("吃点开胃菜..");
        System.out.println("喝点汤....");
        System.out.println("吃点龙虾....");
        System.out.println("吃青菜....");
        System.out.println("喝两杯....");
        System.out.println("吃点甜品....");    
        return new Animal();
    }

}

class Demo10{

    public static void main(String[] args) 
    {
        Zi z = new Zi("大头儿子");
        z.eat();
    
    }
}

 

 

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

 

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

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

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

 

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

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

 

 

五、instanceof关键字

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

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

instanceof关键字的使用格式：

对象 instanceof 类别

一般我们做强制类型转换之前都会使用该关键字先判断一把，然后在进行转换的

class Animal{

    String name;

    String color;

    public Animal(String name, String color){
        this.name = name;
        this.color = color;
    }
}


//狗是属于动物中一种
class Dog extends Animal {

    public Dog(String name,String color){
        super(name,color); //指定调用父类两个 参数的构造函数。
    }

    public void bite(){
        System.out.println(name+"咬人!!");
    }
}

//老鼠 也是属于动物中一种
class Mouse extends  Animal{
    
    public Mouse(String name,String color){
        super(name,color);
    }
    
    public void dig(){
        System.out.println(name+"打洞..");
    }

}

class Demo12{

    public static void main(String[] args) 
    {
        Dog d = new Dog("哈士奇","白色");
        System.out.println("狗是狗类吗？"+ (d instanceof Dog));　　　　　　　　//true
        System.out.println("狗是动物类吗？"+ (d instanceof Animal));    　　　//true
        //System.out.println("狗是老鼠类吗？"+ (d instanceof Mouse));        // 报错   判断的对象与指定的类别必须要存在继承或者实现的关系
        
        Animal a = new Animal("狗娃","黄色"); //狗娃是人
        System.out.println("动物都是狗吗？"+ (a instanceof Dog));　　　　　　　//false


    }
}