案例:编程实现People类的封装,特征有:姓名 年龄 国籍 要求提供打印方法
编程实现PeopleTest类,main方法中使用有参方式构造两个对象打印

//编程实现People类的封装,特征有:姓名 年龄 国籍 要求提供打印方法
public class People{
    private String name;
    private int age;
    private String country;
    public People(){    }
    public People(String name,int age,String country){
        setName(name);
        setAge(age);
        setCountry(country);
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        if(age>0 &&age<150){
            this.age=age;
        }else{
            System.out.println("年龄不合理哟~");
        }
    }
    public int getAge(){
        return age;
    }
    public void setCountry(String country){
        this.country=country;
    }
    public String getCountry(){
        return country;
    }
    public void show(){
        System.out.println("我是"+getName()+",今年"+getAge()+",来自"+getCountry());
    }
}

//编程实现PeopleTest类,main方法中使用有参方式构造两个对象打印
public class PeopleTest{
    public static void main(String[] args){
        People p1=new People("张飞",30,"china");
        p1.show();
        People p2=new People("关羽",35,"china");
        p2.show();
    }
}

static关键字

1.static基本概念

• 使用static关键字修饰成员变量表示静态的含义,此时成员变量由对象层级升为类层级,也就是整个类只有一份并被所有对象共享,该成员变量随着类的加载准备就绪,与是否创建对象无关.
  
• static关键字修饰的成员可以使用引用.的方式访问,但推荐类名.的方式
  

//Test类中验证static关键字修饰的静态成员变量是否被所有对象共享
//People类中
public static String country;
//Test类中
p1.country="蜀国";
System.out.print("第一个对象的国籍是:"+p1.country);//蜀国
System.out.print("第二个对象的国籍是:"+p2.country);//蜀国

2.static使用方式

public class StaticTest{
    private int cnt=1;
    private static int ant=2;
    //自定义非静态的成员方法,需要使用引用.的方式访问
    public void show(){
        System.out.println(cnt);
        System.out.println(ant);
    }
    public static void main(String[] args){
        StaticTest st=new StaticTest();
        st.show();
    }
}
    //自定义静态的成员方法,推荐使用类名.的方式访问
public static void Test(){
        System.out.println(cnt);//静态成员方法中没有this关键字
        System.out.println(ant);
}
● 在非静态成员方法中既能访问非静态的成员又能访问静态的成员
(成员:成员变量+成员方法,静态成员被所有成员访问)
● 在静态成员方法中只能访问静态成员不能访问非静态成员
(成员:成员变量+成员方法,因此此时可能还没有创建对象)
● 在以后的开发中只有隶属于类层级并被所有对象共享的内容才可以使用static关键字修饰.(不能滥用static关键字)

构造块和静态代码块(熟悉)

//编程实现构造块和静态代码块的使用
public class BlockTest{
    //当需要在执行构造方法体之前做一些准备工作时,
    //则将准备工作的相关代码写在构造块中即可
    //比如:对成员变量进行统一初始化操作
    {
        System.out.println("构造块!");
    }
    //自定义构造方法
    public BlockTest(){
        System.out.println("构造方法体");
    }
    //静态代码块会随着类的加载而准备就绪,会先于构造块执行
    static{
        System.out.println("静态代码快");
    }
    public static void main(String[] args){
        BlockTest bt=new BlockTest();
        BlockTest bt2=new BlockTest();
    }
}
● 构造块:在类体中直接使用{}括起来的代码块.
● 每创建一个对象都会执行一次代码块
● 静态代码块:使用static 关键字修饰的构造块
● 静态代码块随着类加载时执行一次

main方法的详解

语法格式:public static void main(String[] args){}
参数使用的举例

//编程实现main方法的测试
public class MainTest{
    public static void main(String[] args){
        System.out.println("参数数组中元素的个数是:"+args.length);
        System.out.println("传递给main方法的实际参数为:");
        for(int i=0;i<args.length;i++){
            System.out.println("下标为:"+i+"的形参变量数值为:"+args[i]);
        }
    }
}

Singleton和SingletonTest类的框架实现(重中之重)

案例:编程实现Singleton类的封装
编程实现SingletonTest类对Singleton类进行测试,要求main方法中能得到且只能得到该类的一个对象

public class Singleton{
    //2.声明本类类型的引用指向本类类型的对象
    private static Singleton sin=new Singleton();
    //1.私有化构造方法 使用private关键字修饰
    private Singleton(){
    }
    //3.提供共有的get方法负责将对象返回出去,使用public static关键字
    public static Singleton getInstance(){
        return sin;
    }
}

public class SingletonTest{
    public static void main(String[] args){
        //Singleton s1=new Singleton();
        //Singleton s2=new Singleton();
        //比较变量s1和s2是否相等
        //System.out.println(s1==s2)//false
        Singleton s1=Singleton.getInstance();
        Singleton s2=Singleton.getInstance();
        System.out.println(s1==s2);//true;
    }
}

执行流程和内存结构分析

单例设计模式

在某种特殊场合中,一个类对外提供且只提供一个对象时,这样的类叫做单例类,而设计单例的流程和思想叫做单例设计模式
单例设计模式的实现流程

• 私有化构造方法,使用private关键字修饰
  
• 声明本类类型的引用指向本类类型的对象,并使用private static关键字共同修饰
  
• 提供公有的get方法负责将对象返回出去,并使用public static 关键字共同修饰
  

单例设计模式的实现方式
有两种:饿汉式和懒汉式,在以后的开发中推荐使用饿汉式

public class Singleton{
    //2.声明本类类型的引用指向本类类型的对象
    private static Singleton sin=new Singleton();//饿汉式
    //private static Singleton sin=null;          //懒汉式
    //1.私有化构造方法 使用private关键字修饰
    private Singleton(){
    }
    //3.提供共有的get方法负责将对象返回出去,使用public static关键字
    public static Singleton getInstance(){
        //if(null==sin){            //懒汉式
        //    sin=new Singleton();
        //}
        return sin;
    }
}

继承

• 当多个类之间有相同的特征和行为时,可以将相同的内容提取出来组成一个公共类,让多个类吸收公共类中已有特征和行为而在多个类型中需要编写自己独有特征和行为的机制叫做继承.
  
• 在java语言中使用extends(扩展)关键字来表示继承
• 如:

public class Worker extends Person(){} 表示Worker类继承自Person类
其中Person类叫做超类 父类 基类
其中Worker类叫做派生类 子类 孩子类

继承的意义

使用继承提高了代码的复用性,可维护性以及扩展性,是多态的前提条件

//编程Person类
public class Person{
    private String name;
    private int age;
    public Person(){
    }
    public Person(String name,int age){
        setName(name);
        setAge(age);
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        if(age>0&&age<150){
            return age;    
        }else{
            System.out.println("不合理");
        }
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
    //自定义成员方法实现特征的打印1
    public void show(){
        System.out.println(getName()+","+getAge());
    }
    public void eat(String food){
        System.out.println(food+"真好吃");
    }
    public void game(String game){
        System.out.println(game+"真好玩");
    }
}

//自定义Worker类继承Person 类
public class Worker extends Person{
}

//Worker类的测试
public class WorkerTest{
    public static void main(String[] args){
        Worker w1=new Worker();
        w1.show();
    }
}

继承的特点

• 子类不能继承父类的构造方法和私有方法,但私有成员变量可以被继承只是不能直接访问 ```java //自定义Worker类继承Person 类 public class Worker extends Person{

    private int salary;
    public Worker(){}
    public Worker(String name,int age,int salary){
        setName(name);
        setAge(age);
        setSalary(salary);
    }
    public int getSalary(){
        return salary;
    }
    public void setSalary(int salary){
        if(salary>=2200){
            this.salary=salary;
        }else{
            System.out.println("不合理");
        }
    }
    public void work(){
        System.out.println("今天又是充满希望的一天!");
    }

  }

```java
//Worker类的测试
public class WorkerTest{
    public static void main(String[] args){
        Worker w1=new Worker();
        w1.show();
        System.out.println("-------");
        Worker w2=new Worker("张飞",30,3000);
        w2.show();
        w2.eat("豆芽");
        w2.game("王者荣耀");
        w2.work();
    }
}

• 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法,来初始化从父类中继承的成员变量,相当于在构造方法的第一行增加super()的效果

• 使用继承必须满足逻辑关系:子类is a 父类,也就是不能滥用继承
  
• Java语言中只支持单继承不支持多继承,也就是说一个子类只能有一个父类,但一个父类可以有多个子类
  

  方法重写和使用

  从父类中继承下来的方法不满足子类的需求时,就需要在子类中重新写一个和父类一样的方法来覆盖从父类继承下来的版本,该方法就叫做方法的重写(Override) ```java //自定义show方法覆盖从父类中继承的版本 @override //标注/注解 用于说明下面的方法时对父类方法的重写,若没有构成重写则编译错误 public void show(){ super.show();//表示调用父类的show方法 System.out.println(“我的薪水是:”+salary); }

<a name="xgVvu"></a>
## **静态块与静态代码块(笔试)**
```java
package com.lagou.task08;
/**
 * @author lijing
 * @date 2020/9/18 16:24
 * @description
 */
public class SuperTest {
    {
        System.out.println("SuperTest类中的构造块");
    }
    static {
        System.out.println("SuperTest类中的静态代码块");
    }
    public SuperTest(){
        System.out.println("SuperTest中的构造方法体");
    }
    public static void main(String[] args) {
        SuperTest st=new SuperTest();
    }
}

package com.lagou.task08;
/**
 * @author lijing
 * @date 2020/9/18 16:27
 * @description
 */
public class SubSuperTest extends SuperTest{
    {
        System.out.println("SuperTest类中的构造块2");
    }
    static {
        System.out.println("SuperTest类中的静态代码块2");
    }
    public SubSuperTest(){
        System.out.println("SuperTest中的构造方法体2");
    }
    public static void main(String[] args) {
        SubSuperTest sst=new SubSuperTest();
    }
}
--------------------------------------
   结果:
结果
SuperTest类中的静态代码块
SuperTest类中的静态代码块2
SuperTest类中的构造块
SuperTest中的构造方法体
SuperTest类中的构造块2
SuperTest中的构造方法体2
● 先执行父类的静态代码块,在执行子类的静态代码块
● 执行父类的构造块,执行父类的构造方法体
● 执行子类的构造块,执行子类的构造方法体