1 单例设计模式

1.1 饿汉单例设计模式

单例设计模式：保证一个类中至少有一个对象

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

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

? 单例设计模式

? 模板设计模式

? 装饰者设计模式

? 观察者设计模式

? 工厂设计模式

单例设计模式的步骤：

? 1.私有化构造函数

? 2.声明本类的引用类型变量，并且使用该变量指向本类的对象

? 3.提供一个公共的方法获取本类的对象

class Single{
    private static Single s = new Single();
 	private Single(){
        
    }  
    public static Single getInstance(){
        return s;
    }
}
class demn{
    public static void main(String[] args){
       	Single s1 = Single.getInstance();
        Single s2 = Single.getInstance();
        System.out.println(s1 == s2);//true
    }
    
}

1.2 懒汉设计模式

懒汉单例设计模式：

? 1.私有化构造函数

? 2.声明本类的引用变量，但是不要创建变量

? 3.提供公共的静态方法获取本类的对象，获取之前判断是否已经创建了本类的对象，如果已经创建了，直接返回对象，如果没有创建，先创建本类的对象，然后再返回

class Single{
    private static Single s;
    private Single(){
        
    }
   	public static Single getInstance(){
        if(s == null){
            s = new Single();
        }
        return s;
    }
}

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

2 继承

在现实生活中，事物和事物之间是存在关系

球员------->球队 整体和部分的关系

//球员类
class Player{
    int num;
    String name;
  
    public Player(int num, String name){
        this.num = num;
        this.name = name;
    }
    public void run(){
        System.out.println(name + "开炮");
    }
}
//球队类
class Team{
    String name;
    Player p1;
    Player p2;
    Player p2;
    public Team(String name, Player p1, Player p2, Player p3){
        this.name = name;
        this.p1 = p1;
        this.p2 = p2;
        this.p3 = p3;
    }
    public void startGame(){
        System.out.println(name + "the game is beginning");
    }
}
class demn{
    public static void main(String[] args){
        Player p1 = new Player(12, "梅西");
        Player p2 = new Player(13, "c罗");
        Player p3 = new Player(14, "内马尔");
        
        //组建一个球队
        Team t = new Team("恒大");
        t.startGame();
       	
        System.out.println("名字" + t.p1.name);
    }
    
}

学生 ----------> 人类

目前存在的问题：无法描述出这两个类的继承关系，而且存在着重复代码

class Person{
    String name;
    private int age;
    public Person(String name){
        this.name = name;
    }
    public Person(){
        System.out.println("person的构造方法被调用了");
    }
    public void eat(){
        System.out.println(name + "在吃饭");
    }
}
class Student extends Person{//student称为Person类的子类，Person类称为Student的父类，超类，基类
    int num;
    public Student(){
        System.out.println("Student的构造方法被调用了");
    }
    public void study(){
        System.out.println("good study day day up");
     	
    }
}
class demn{
    public static void main(String[] args){
        Student s = new Student();  //person and student 的构造方法都调用了
        /*s.name = "狗娃";
        System.out.println("名字" + s.name);
        */
    }
}

继承的格式：

? class 类名1 extends 类名2{

}

继承要主义的事项：

? 1.父类私有的成员不可以被继承

? 2.父类的构造函数不可以被继承

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

? 疑问：为什么要调用父类的构造方法

? 1.调用父类的构造方法是可以初始化从父类继承到的属性

class fu{
    int x = 10;
    String name;
    public fu(String name){
        this.name = name;
    }
    public fu(){
        System.out.println("fu类无参的构造方法");
    }
}
class zi extends fu{
    int x = 20;
    public zi(String name){
        super(name);//指定调用父类一个参数的构造函数
    }
    public void print(){
        System.out.println("x1 = " + x);//就近原则
        System.out.println("x2 = " + super.x);
        
    }
}
class demn{
    public static void main(String[] args){
        zi z = new zi();
        z.print();
        System.out.println("name = " + z.name);//null
        
        zi z2 = new zi("大头儿子");
        System.out.println("name = " + z.name);
    }
}

3 super

super关键字代表父类空间的引用
super关键字的作用:
	1.子父类存在着同名的成员（包括变量和方法）时，在子类中是访问子类的成员，可以通过super关键字指定访问父类的成员
    2.创建子类对象时，默认会调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法
        
super关键字要注意的事项：
    1.如果在子类的构造没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上加上super();
	2.super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一条语句
    3.super关键字与this关键字不能同时出现在同一个构造函数中调用其他的构造函数
class fu{
    int x = 10;
    String name;
    public fu(){
        System.out.println("父类无参的构造方法");
        
    }
    public fu(String name){
        this.name = name;
        System.out.println("父类有参的构造方法");
    }
    public void eat(){
        System.out.println("小头爸爸吃东西");
    }
}
class zi extends fu{
    int x = 20;
    int num;
    public zi(String name, int num){
        this.num = num;
        //this();//调用本类无参的构造方法,报错，this和super都需要位于第一条语句的位置
        //System.out.println("zi类带参的构造方法");
        super(name);//报错，对super的调用必须是第一条语句
        //super();//指定调用父类无参的构造方法
    }
    public zi(){
        System.out.println("子类无参的构造方法");
    }
    public void print(){
        system.out.println("x = " + super.x);
        
    }
    public void eat(){
        System.out.println("小头儿子吃荣霞");
    }
}
class demn{
    public static void main(String[] args){
        zi z = new zi("狗娃");
        
    }
}

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

class fu{
    String name;
    public fu(String name){
        this.name = name;
    }
    public void eat(){
        System.out.println(name + "吃紫薯");
        
    }
}
class zi extends fu{
    String num;
    public zi(String name){
        super(name);
    }
}
class demn{
    public static void main(String[] args){
        zi z = new zi();//报错，调用了子类的无参构造方法后，因为没有指定调用父类的方法，就会调用到了父类的无参的构造方法，但是父类没有无参的构造方法，报错
    
    }
    z.eat();
    
}
//父类的功能无法满足子类的需求

4 方法的重写

方法的重写：子父类出现了同名函数这就称为方法的重写
什么时候要使用方法的重写：父类的功能无法满足子类的需求
方法的重载：在一个类中出现了两个或者两个以上的同名函数就称为方法的重载
方法重写的前提：必须要存在继承的关系
方法重写要注意的事项：
    1.方法名和形参列表必须一致
    2.方法重写的时候，子类的权限修饰符必须大于或者等于父类的权限修饰符
    3.方法重写时，子类的返回值类型必须要小于或者等于父类的返回值类型
    4.方法重写时，子类抛出的异常类型要小于或者等于父类抛出的异常类型
    Exception（最坏）
    RuntimeException（小坏）
方法重载的要求：
    1.函数名要一致
    2.形参列表要一致（形参的个数，与形参的类型）
    3.与返回值类型无关
class Animal{//大的数据类型
    
}
class Fish extends Animal{//小的数据类型
    
}
class fu{
    String name;
    public fu(String name){
        this.name = name;
    }
    public Animal eat(){
        System.out.println(name + "吃紫薯");
        return new Animal();
    }
}
class zi extends fu{
    String num;
    public zi(String name){
        super(name);
    }
    public Animal eat(){
        System.out.println("吃开胃菜，喝点汤");
        return new Animal();
    }
}

5 继承的练习

class Student{
    String name;
    public student(String name){
        this.name = name;
    }
    public void study(){
        System.out.println("学习");
    }
}
class basestudent extends Student{
    public basestudent(String name){
        super(name);
    }
    public void study(){
        System.out.println("学习java");
    }
}
class workstudent extends student{
    public workstudent(String name){
        super(name);
    }
    public void study(){
        super.study();
        System.out.println(name + "学习javaee and android");
    }
}
class demn{
    public static void main(String[] args){
        basestudent s = new basestudent("据东东");
        s.study();
        
        workstudent w = new workstudent("张三");
        w.study();
    }
}

6 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("会咬人");
    }
}
class Mouse extends Animal{
    public Mouse(string name, String color){
        super(name, color);
    }
    public void dig(){
        System.out.println(name + "打洞");
    }
}
class demn{
    public static void main(String[] args){
        dog d - new dog("哈士奇", "白色");
        d.bite();
        System.out.println(dog instanceof dog);//true
        System.out.println(dog instanceof Animal);//true
        System.out.println(dog instanceof Mouse);//报错，无继承关系
        Animal a = new Animal("狗娃", "黄色");
        System.out.println("动物都是狗类吗" + (a instanceof dog));//false
    }
}

08.继承

原文：https://www.cnblogs.com/best-you-articles-040612/p/14799596.html