java入门3

• 代码块概述
• • 静态代码块
  • 实例代码块（了解，用的少）
• 设计模式
• • 单例模式
  • • 饿汉单例设计模式
    • 懒汉单例设计模式
• 面向对象三大特征之二：继承
• • Demo
• 方法重写
• • 子类继承父类后构造器的特点
  • • Demo

代码块是类的5大成分之一（成员变量，构造器，方法，代码块，内部类），定义在类中方法外。
在JAVA类下，使用{}括起来的代码被称为代码块

格式：static{}
特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次
使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。

import java.util.ArrayList;

public class staticcode {

    
    public static String s;
    public static ArrayList list=new ArrayList<>();
    static {
        System.out.println("=====静态代码块被触发======");
        s="someday";
        list.add(1);
        list.add(3);
    }

    public static void main(String[] args) {
        System.out.println("=====main执行======");
        System.out.println(s);
        System.out.println(list);

    }
}

//输出结果
//=====静态代码块被触发======
//=====main执行======
//someday
//[1, 3]

格式：{}
特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行。
使用场景：初始化实例资源

public class staticcode2 {
    private String name;
    public staticcode2(){
        System.out.println("无参构造器被执行");
    }
    
    {
        name="tony";
        System.out.println("实例代码块被执行");
    }

    public static void main(String[] args) {
        staticcode2 s1=new staticcode2();
        System.out.println(s1.name);

        staticcode2 s2=new staticcode2();
        System.out.println(s2.name);
    }
}

开发中经常遇到一些问题，一个问题通常有n种解法，但其中肯定有一种解法时最优的，这个最优的解法被人总结出来称为设计模式。
设计模型有20多种，对应20多种软件开发中会遇到的问题。
学习设计模式主要是学2点：
1.这种模式用来解决什么问题。
2，遇到这种问题，该模型是怎么写的，他是如何解决这个问题。

保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。

在用类获取对象的时候，对象已经提前为你创建好了
设计步骤：
定义一个类，把构造器私有。
定义一个静态变量存储一个对象。

public class SingleInstance {
    
    public static SingleInstance instance=new SingleInstance();

    
    private SingleInstance(){

    }
}

public class singletest {
    public static void main(String[] args) {
        SingleInstance s1= SingleInstance.instance;
        SingleInstance s2= SingleInstance.instance;
        System.out.println(s1==s2);

    }
}

在真正需要该对象的时候，才去创建一个对象（延迟加载对象）
设计步骤：
定义一个类，把构造器私有。
定义一个静态变量存储一个对象。
创建一个返回单例对象的方法。

public class SingleInstance1 {
    private SingleInstance1(){

    }
    private static SingleInstance1 instance1;

    public static SingleInstance1 getInstance(){
        if (instance1==null){
            //为null的时候，为第一次创建
            instance1=new SingleInstance1();
        }
        return instance1;
        
    }
}

public class singletest1 {
    public static void main(String[] args) {
        SingleInstance1 s1=SingleInstance1.getInstance();
        SingleInstance1 s2=SingleInstance1.getInstance();
        System.out.println(s1==s2);

    }
}

Java中提供的关键词extends，用这个关键字，可以让一个类和另一个类建立起父子关系。
提高代码复用性，减少代码冗余，增强类的功能扩展型，

public class Student extends People{}

Student称为子类（派生类），People称为父类（基类或超类）。
Java中子类更强大。
作用：当子类继承父类后，就可以直接使用父类公共的属性和方法了。

public class People {
    
    public void run(){
        System.out.println("renhuipao");
    }
}

public class Student extends People{
    

}

public class test {
    public static void main(String[] args) {
        Student s=new Student();
        s.run();
    }
}

public class People {
    
    private String name;
    private int age;

    public void queryCourse(){
        System.out.println(name+"在查看课表~~");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Student extends People{
    
    public void writerInfo(){
        System.out.println(this.getName()+"写下了");
    }

}

public class test {
    public static void main(String[] args) {
        Student s=new Student();
        s.setName("tom");
        s.setAge(18);
        s.queryCourse();
        s.writerInfo();

    }
}

继承的特点：
1.子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
2.Java是单继承模型：一个类只能继承一个直接父类。
3.Java不支持多继承、但是支持多层继承。
比如A不能同时继承B和C，但A可以继承B，同时B可以继承C。
4.Java中所有的类都是Object类的子类。

在子类方法中访问成员（成员变量、成员方法）满足：就近原则
先子类局部范围查找
然后子类成员范围查找
然后父类成员范围查找，如果父类还没有找到则报错。

如果子父类中出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类怎么办？
可以通过super关键字，指定访问父类成员

public class Demo {

    public static void main(String[] args) {
        dog d=new dog();
        d.showname();

    }
}

class Animal{
    public String name="动物";

}
class dog extends Animal{
    public static String name="狗";
    public void showname(){
        String name="哈士奇";
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

//输出结果
哈士奇
狗
动物

在继承体系中，子类出现了和父类中一摸一样的方法声明，我们就称子类这个方法是重写的方法

应用场景
当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。
子类可以重写父类中的方法。

public class test {
    public static void main(String[] args) {
        newphone p=new newphone();
        p.call();
        p.message();

    }
}


class oldphone{
    public void call(){
        System.out.println("call");
    }
    public void message(){
        System.out.println("message");
    }

}

class newphone extends oldphone{
    @Override //添加override后，1.如果重写错误，编译会出错，比如将call写成call1会报错。  2.代码可读性高
    public void call(){
        super.call();
        System.out.println("facetime");
    }
    @Override
    public void message(){
        super.message();
        System.out.println("picture");
    }

}

子类中所有的构造器默认都会先访问父类中无参构造器，再执行自己。
原因：
子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。

调用父类有参构造器

public class People {
    
    private String name;
    private int age;
    public People(){

    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Student extends People {
    
    public Student(){

    }
    public Student(String name,int age){


        super(name,age);
    }

}

public class test {
    public static void main(String[] args) {
        Student s=new Student("ds",33);
        System.out.println(s.getName());
        System.out.println(s.getAge());


    }
}