第七周Java作业

本周主题：面向对象程序设计（一）

一、类和对象的概念

    类和对象是面向对象最基本、最重要的两个概念，在本节中通过Student类及实例对象的创建，来介绍类与对象的创建方法，成员变量、成员方法定义的基本格式，以及信息的封装与隐藏。

    了解面向对象的概念，熟记类与对象的概念，熟记构造方法及方法重载的特点，熟知this和static的使用方法，掌握类的继承、抽象类、接口的概念，熟知方法重写的特点，了解多态的含义和实际应用。

1、知识脉络图：

2、类的定义基本格式：

[修饰符] class <类名> [extends 父类名] [implements 接口1, 接口2, ... ...] {
     类体
}

3、修饰符分为：访问控制修饰符和非访问控制修饰符

3.1、访问控制修饰符的作用域（访问范围）：

3.2、非访问控制修饰符及含义：

    

static、final、abstract的更多详细内容可阅读博主的另一篇文章：https://blog.csdn.net/xieyunc/article/details/102643543
 

二、一个简单的类的定义的例子：

定义一个学生类：Student

 测试一个测试类：TestStudent

执行结果：

三、改造上述Student类的定义

    增加以下内容的学生类：Student：

1. 静态成员常量
2. 静态成员方法
3. 构造方法
4. 动态代码块
5. 静态代码块   

//如果一个类/成员变量/成员方法，没有明确声明访问修饰符，则为默认的访问修饰符 default，它们的作用域为本包。
class Student {
    //如果此处已为schoolName赋了初值，那么其它作任何地方都不允许再有对schoolName进行赋值的语句了。
    //static final String schoolName = "江西科技师范大学";//校名，静态成员变量
    static final String schoolName;//校名，静态成员变量
    String name;    //姓名
    int age;        //年龄

    {
        /*动态代码块，每创建(实例化)一个对象时均会执行*/
        name = "李寻欢";
        age = 28;
    }

    static {
        /*静态代码块，第一次使用类时才会执行，而且只会执行一次*/
        //也可以在声明schoolName变量的地方初始化，不能同时在这两个地方均有赋值语句，只能二选一。
        schoolName = "江西科技师范大学"; 
        System.out.println("Student类的静态代码块被执行！");
    }

    public Student() {
    }

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

    public void show() {
        System.out.printf("学校：%s\t姓名：%s\t年龄：%d\n",schoolName,name,age);
    }

    public static String getSchoolName() {
        return schoolName;
    }
}

    增加了调用自定义构造方法的测试类：

/**
 * 文件名：TestStudent.java
 * 功能描述：对Student类进行测试的类
 */
public class TestStudent {
    public static void main(String[] args) {

        //通过“类名.变量名”直接调用静态成员变量
        System.out.println("调用Student.schoolName的结果："+Student.schoolName);

        //通过“类名.方法名”直接调用静态方法
        System.out.println("调用Student.getSchoolName()的结果："+Student.getSchoolName());

        //Student.schoolName = "软件动漫学院"; //语法错误，schoolName为最终变量（常量）
        //Student.show();//语法错误，show()为普通成员方法，不能通过类名直接调用

        System.out.println("-----------------------------------------------");
        Student stu1 = new Student();

        //通过“对象名.方法名”直接调用静态方法
        System.out.println("调用stu1.getSchoolName()的结果："+stu1.getSchoolName());

        stu1.show();//普通方法只能通过“对象名.方法名”的方式调用

        Student stu2 = new Student("张三丰",20);

        //通过“对象名.方法名”直接调用静态方法
        System.out.println("调用stu2.getSchoolName()的结果："+stu2.getSchoolName());
        stu2.show();//普通方法只能通过“对象名.方法名”的方式调用
    }
}

    执行结果：

四、static修饰符演示Demo

    staticTest类的定义：

/**
 * 文件名：StaticTest.java
 * 功能描述：static修饰符的测试类
 */
class StaticTest{
    private static int count = 0 ;//用于统计实例化了多少个本类的对象
    public StaticTest(){
        count ++;
        System.out.printf("正在实例化第%d个对象……\n",count);
    }

    public static void show() {
        System.out.println("count="+count);
    }
}

    测试类：

/**
 * 文件名：MyTest.java
 * 功能描述：测试staticTest类中的静态方法
 */
public class MyTest{
    public static void main(String args[]){
        //1、通过类名调用静态方法，通过类名调用静态成员变量或静态成员方法并不会实例化对象
        StaticTest.show();
        StaticTest.show();

        System.out.println("-------------------------");

        //2、通过对象调用静态方法
        StaticTest myTest1 = new StaticTest();
        myTest1.show();
        StaticTest myTest2 = new StaticTest();
        myTest2.show();

        StaticTest.show();
    }
}

     执行结果：

五、设计一个Singleton模式（单例模式）的类

    单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

    这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

介绍：

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

应用实例：

• 1、一个班级只有一个班主任。
• 2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
• 3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

优点：

• 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
• 2、避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

• 1、要求生产唯一序列号。
• 2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
• 3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

更多单例模式--singleton的知识，请参考：https://www.runoob.com/design-pattern/singleton-pattern.html

    Singleton类的定义（饿汉式）：

/**
 * Singleton模式，即单例模式，在一个程序中只允许创建唯一一个实例的类，Singleton类的声明规则如下：
 * 1、类的构造方法的访问控制修饰符为 private，外界不能通过new创建该类的实例。
 * 2、在类的内部通过一个私有的静态属性引用该类的实例，禁止外界直接访问该属性。
 * 3、创建一个public static的get()方法，以使得外界能够获取该类的实例，由于该方法是静态的，因此
 *    可以通过 类名.方法名() 的方式来调用该方法。
 */
public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {
        System.out.println("我是一个Singleton模式的类："+this.hashCode());
    }

    public static Singleton getInstance() {
        return instance;
    }
}

    测试类： 

public class SingletonTest {
    public static void main(String[] args) {
        Singleton single1 = Singleton.getInstance();
        Singleton single2 = Singleton.getInstance();

        if (single1.equals(single2)) {
            System.out.println("只有一个单例模式的实例对象！");
        } else {
            System.out.println("违背事实！");
        }

        System.out.printf("实例对象Single1的哈希码为：%d\n", single1.hashCode());
        System.out.printf("实例对象Single2的哈希码为：%d\n", single2.hashCode());

    }
}

    运行结果： 

六、演示DEMO源代码在github上的仓库地址：

https://github.com/xieyunc/java_demo.git