目录
第三章 面向对象
- 面向对象概念
- 类与对象的关系
- 封装
- 构造函数
- this关键字
- static关键字
- 单例设计模式
面向对象概念
- 理解面向对象
- 面向对象的特点
理解面向对象
- 面向对象是相对面向过程而言
- 面向对象和面向过程都是一种思想
- 面向过程
- 强调的是功能行为
- 面向对象
- 将功能封装进对象，强调具备了功能的对象。
- 面向对象是基于面向过程的。
面向过程：打开冰箱 -> 存储进冰箱 -> 关闭冰箱
面向对象：冰箱.打开 -> 冰箱.存储 -> 冰箱.关闭
面向对象的特点
- 是一种符合人们思考习惯的思想
- 可以将复杂的事情简单化
- 将程序员从执行者转换成了指挥者
- 完成需求时：
- 先要去找具有所需的功能的对象来用。
- 如果该对象不存在，那么创建一个具有所需功能的对象。
- 这样简化开发并提高复用。
面向对象开发，设计，特征
- 开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
- 设计的过程：其实就是在管理和维护对象之间的关系。
- 面向对象的特征：
- 封装(encapsulation)
- 继承(inheritance)
- 多态(polymorphism)
类与对象的关系
- 使用计算机语言就是不断的在描述现实生活中的事物。
- Java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。
- 对象即是该类事物实实在在存在的个体。
/*
人开门：名词提炼法。
*/
人{
开门(门){
门.开():
}
}
门{
开(){
操作门轴等。
}
}
类与对象（图例）
类的定义
- 生活中描述事物无非就是描述事物的属性和行为。
- 如：人有身高，体重等属性，有说话，打球等行为。
- Java中用类class来描述事物也是如此
- 属性：对应类中的成员变量。
- 行为：对应类中的成员函数。
- 定义类其实在定义类中的成员（成员变量和成员函数）。
成员变量和局部变量的区别？
- 成员变量：
- 成员变量定义在类中，在整个类中都可以被访问。
- 成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
- 成员变量有默认初始化值。
- 局部变量：
- 局部变量只定义在局部范围内，如：函数内，语句内等。
- 局部变量存在于栈内存中。
- 作用的范围结束，变量空间会自动释放。
- 局部变量没有默认初始化值。
创建对象，使用对象
public class Car { // 对Car这类事物进行描述
String color = "red";
int num = 4;
void show() {
System.out.println("color = " + color + "..num = " + num); // color = black..num = 4
}
class CarDemo {
public static void main(String[] args) {
demo c = new demo(); // 建立对象
c.color = "black"; // 对象的属性进行修改
c.show(); // 使用对象的功能。
}
}
对象内存结构
匿名对象
- 匿名对象是对象的简化形式
- 匿名对象两种使用情况
- 当对对象方法仅进行一次调用的时候
- 匿名对象可以作为实际参数进行传递
/*
* 面向对象：三个特征：封装，继承，多态。
* 以后开发：其实就是找对象使用。没有对象，就创建一个对象。
* 找对象，建立对象，使用对象。维护对象的关系。
*
* 类和对象的关系。
* 现实生活中的对象：张三 李四。
* 想要描述：提取对象中共性内容。对具体的抽象。
* 描述时：这些对象的共性有：姓名，年龄，性别，学习Java功能。
*
* 映射到Java中，描述就是class定义的类。
* 具体对象就是对应Java在堆内存中用new建立实体。
*
* 类就是：对现实生活中事物的描述。
* 对象：就是这类事物，实实在在存在个体。
* */
// 需求：描述汽车（颜色，轮胎数）。描述事物其实就是在描述事物的属性和行为。
// 属性对应是类中变量，行为对应类中的函数（方法）。
// 定时定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员（成员变量和成员方法）。
/*
* 成员变量和局部变量
* 作用范围：
* 成员变量作用于整个类中。
* 局部变量作用于函数中，或者语句中。
* 在内存中的位置：
* 成员变量：在堆内存中，因为对象的存在，才在内存中存在。
* 局部变量：存在栈内存中。
* */
public class Car {
// 描述颜色
String color = "red";
// 描述轮胎数
int num = 4;
// 运行行为
void run() {
System.out.println(color + ".." + num);
}
public static void main(String[] args) {
// 生产汽车。在Java中通过new操作符来完成。
// 其实就是在堆内存产生一个实体。
Car c = new Car(); // c就是一个类类型变量。记住：类类型变量指向对象。
// 需求：将已有车的颜色改成蓝色。指挥该对象做使用。在Java指挥方式是：对象.对象成员
c.color = "blue";
c.run(); // blue..4
Car c1 = new Car();
c1.run(); // red..4
Car c2 = new Car();
c2.num = 5;
Car c3 = c2;
c3.color = "green";
c3.run(); // green..5
c2.run(); // green..5
new Car().num = 5;
new Car().color = "blue";
new Car().run(); // red.4
Car c4 = new Car();
c4.run(); // red..4
c4.num = 4;
new Car().run(); // red..4
/*
* 匿名对象是用方式一： 当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。 如果对一个对象进行多个成员调用，必须给这个对象起个名字。
* 匿名对象使用方式二： 可以将匿名对象作为实际参数进行传递。
*/
Car q = new Car();
show(q); // black..3
show(new Car()); // black..3
}
// 需求：汽车修配厂。对汽车进行改装，将来的车都改成黑车，三个轮胎。
public static void show(Car c) {
c.num = 3;
c.color = "black";
c.run();
}
}
封装（Encapsulation）
- 封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
- 好处：
- 将变化隔离。
- 便于使用。
- 提高重用性。
- 提高安全性。
- 封装原则：
- 将不需要对外提供的内容都隐藏起来。
- 把属性都隐藏，提供公共方法对其访问。
private（私有）关键字
- private关键字：
- 是一个权限修饰符。
- 用于修饰成员（成员变量和成员函数）
- 被私有化的成员只在本类中有效。
- 常用之一：
- 将成员变量私有化，对外提供对应的set，get方法对其进行访问。提高对数据访问的安全性。
/*
* private：私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数。）
* 私有只在本类中有效。
*
* 将age私有化以后，类以外即使建立了对象也不能直接访问。
* 但是人应该有年龄，就需要在Person类提供对应访问age的方式。
*
* 注意：私有仅仅是封装的一种表现形式。
*
* 之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。
* 对访问的数据进行操作。提高代码健壮性。
* */
class Person {
private int age;
public void setAge(int a) {
if (a > 0 && age < 130) {
age = a;
speak();
} else {
System.out.println("非法年龄");
}
}
public int getAge() {
return age;
}
void speak() {
System.out.println("age = " + age);
}
}
class PersonDemo {
public static void main(String[] args) {
Person p = new Person();
// p.age = -20;
p.setAge(20); // age = 20
p.setAge(-20); // 非法年龄
// p.speak();
}
}
构造函数
-
特点：
- 函数名与类名相同
- 不用定义返回值类型
- 不可以写return语句
-
作用：给对象进行初始化。
-
注意：
- 默认构造函数的特点。
- 多个构造函数是以重载的形式存在的。
构造函数、构造代码块
/*
* 对象一建立就会调用与之对应的构造函数。
*
* 构造函数的作用：可以用于给对象进行初始化。
*
* 构造函数的小细节：
* 当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
* 当在类中自定义了构造函数后，默认的构造函数就没有了。
*
* 构造函数和一般函数在写法上不同。
* 在运行上也有不同。
* 构造函数时在对象一建立就运行。给对象初始化。
* 而一般方法是对象调用才执行，是给对象添加对象具备的功能。
*
* 什么时候定义构造函数呢？
* 当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
* */
class Person {
private String name;
private int age;
/*
* 构造代码块。
* 作用：给对象进行初始化。
* 对象一建立就运行，而且优先于构造函数执行。
* 和构造函数的区别：
* 构造代码块是给所有对象进行统一初始化。
* 而构造函数是给对应的对象初始化。
* 构造代码块中定义的是不同对象共性的初始化内容。
*/
{
System.out.println("person code run");
cry();
}
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
public Person() {
System.out.println("A: name = " + name + ",age = " + age);
}
public Person(String n) {
name = n;
System.out.println("B: name = " + name + ",age = " + age);
}
public Person(String n, int a) {
name = n;
age = a;
System.out.println("C: name = " + name + ",age = " + age);
}
public void cry() {
System.out.println("cry......");
}
}
class PersonDemo2 {
public static void main(String[] args) {
// person code run
// cry......
// A: name = null,age = 0
Person p1 = new Person();
// p1.cry();
// person code run
// cry......
// B: name = lisi,age = 0
// 3
// libusi
Person p2 = new Person("lisi");
p2.setAge(3);
p2.setName("libusi");
System.out.println(p2.getAge());
System.out.println(p2.getName());
// person code run
// cry......
// C: name = wangwu,age = 3
Person p3 = new Person("wangwu", 3);
}
}
this关键字
- 特点：this代表其所在函数所属对象的引用。
- 换言之：this代表本类对象的引用。
- 什么时候使用this关键字呢？
- 当在函数内需要用到调用该函数的对象时，就用this。
this关键字的应用
/*
* this：看上去，是用于区分局部变量和成员变量同名情况。
* this为什么可以解决这个问题？
* this到底代表的是什么呢？
*
* this：就代表本类的对象，到底代表哪一个呢？
* this代表它所在函数所属对象的引用。
* 简单说：哪个对象在调用this所在的函数，this就代表哪个对象。
* this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。
* 但凡本类功能内部使用了本来对象，都用this表示。
* */
class Person {
private String name;
private int age;
public Person(int age) {
this.age = age;
}
public Person(String name) {
this.name = name;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void speak() {
System.out.println("name = " + this.name + "..age = " + this.age);
show();
}
public void show() {
System.out.println(this.name);
}
/*
* 需求：给人定义一个用于比较年龄是否相同的功能。也就是是否同龄人。
*/
public boolean compare(Person p) {
return this.age == p.age;
}
}
class PersonDemo3 {
public static void main(String[] args) {
Person p = new Person("lisi");
Person p1 = new Person("zhangsan");
// name = lisi..age = 0
// lisi
p.speak();
// name = zhangsan..age = 0
// zhangsan
p1.speak();
// name = ss..age = 0
// ss
new Person("ss").speak();
Person p2 = new Person(12);
Person p3 = new Person(12);
boolean b = p2.compare(p3);
System.out.println(b); // true
}
}
this关键字在构造函数间调用
/*
* this语句：用于构造函数之间进行互相调用。
* this语句只能定义在构造函数的第一行。因为初始化要先执行。
* */
class Person {
private String name;
private int age;
{
System.out.println("code run");
}
Person() {
System.out.println("person run");
}
Person(String name) {
this();
this.name = "haha";
}
Person(String name, int age) {
this(name); // p(name)
this.name = name;
this.age = age;
}
public void speck() {
System.out.println(name + ".." + age);
}
}
class PersonDemo4 {
public static void main(String[] args) {
Person p = new Person("lisi1", 30);
p.speck(); // code run/person run/lisi1..30
Person p1 = new Person("lisi2", 36);
p1.speck(); // code run/person run/lisi2..36
}
}
static（静态）关键字
- static关键字：
- 用于修饰成员（成员变量和成员函数）
- 被修饰后的成员具备以下特点：
- 随着类的加载而加载
- 优先于对象存在
- 被所有对象所共享
- 可以直接被类名调用
- 使用注意
- 静态方法只能访问静态成员
- 静态方法中不可以写this，super关键字
- 主函数是静态的
/*
* 静态：static
* 用法：是一个修饰符，用于修饰成员（成员变量，成员函数）。
* 当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外。
* 还可以直接被类名调用。类名.静态成员。
*
* static特点：
* 1. 随着类的加载而加载
* 也就说，静态会随着类的消失而消失，说明它的生命周期最长。
* 2. 优先于对象存在
* 明确一点，静态是先存在，对象是后存在的。
* 3. 被所有对象所共享
* 4. 可以直接被类名所调用
*
* 实例变量和类变量的区别：
* 1. 存放位置：
* 类变量随着类的加载而存在于方法区中。
* 实例变量随着对象的建立而存在于堆内存中。
* 2. 生命周期：
* 类变量生命周期最长，随着类的消失而消失。
* 实例变量生命周期随着对象的消失而消失。
*
* 静态使用注意事项：
* 1. 静态方法只能访问静态成员。
* 非静态方法即可以访问静态也可以访问非静态。
* 2. 静态方法中不可以定义this，super关键字。
* 因为静态优先于对象存在，所以静态方法中不可以出现this。
* 3. 主函数是静态的。
*
* 静态有利有弊：
* 利处：对对象共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
* 可以直接被类名调用。
* 弊端：生命周期过长
* 访问出现局限性（静态虽好，只能访问静态。）
* */
class Person {
String name; // 成员变量（实例变量）
static String country = "CN"; // 静态的成员变量（类变量）
public void show() {
System.out.println(name + "::" + country); // lisi::CN
System.out.println(this.country); // CN
haha();
}
public static void show1() {
System.out.println(country); // CN
// System.out.println(this.country); // error
// System.out.println(name + "::" + country); // error
// haha(); // error
}
public void haha() {
}
}
class StaticDemo {
public static void main(String[] args) {
Person p = new Person();
p.name = "lisi";
p.show();
System.out.println(p.country); // CN
System.out.println(Person.country); // CN
Person.show1();
}
}
main函数
/*
* public static void main(String[] args)
*
* 主函数：是一特殊的函数，作为程序的入口，可以被Java使用。
*
* 主函数的定义：
* public：代表着该函数访问权限是最大的。
* static：代表主函数随着类的加载就已经存在了。
* void：主函数没有具体的返回值。
* main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
* (String[] args):函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串类型的数组。
*
* 主函数是固定格式的：jvm识别。
*
* jvm在调用主函数时，传入的是new String(0);
*/
class MainDemo {
public static void main(String[] arguments) { // new String[]
System.out.println(arguments); // [Ljava.lang.String;@52e922
System.out.println(arguments.length); // 0
// System.out.println(arguments[0]); // java.lang.ArrayIndexOutOfBoundsException越界
String[] arr = { "haha", "hehe", "xixi", "heihei", "giaogiao", "hiahia" };
MainTest.main(arr);
}
}
class MainTest {
public static void main(String[] args) {
for (int x = 0; x < args.length; x++) {
System.out.println(args[x]);
}
}
}
静态是什么时候使用？
/*
* 什么时候使用静态？
*
* 要从两方面下手：
* 因为静态修饰的内容有成员变量和成员函数。
* 什么时候定义静态变量（类变量）呢？
* 当对象中的出现共享数据时，该数据被静态所修饰。
* 对象中的特有数据要定义成非静态存在于堆内存中。
* 什么时候定义静态函数（类函数）呢？
* 当功能内部没有访问到非静态数据（对象的特有数据），
* 那么该功能可以定义成静态的。
* */
静态的应用-工具类
/*
* 静态的应用：
*
* 每一个应用程序中都有共性的功能
* 可以将这些功能进行抽取，独立封装。以便复用。
*
* 虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。
* 发现了问题：
* 1. 对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。
* 2. 操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
*
* 这时就考虑，让程序更严谨，是不需要对象的。
* 可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可。
*
* 将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。
* 为了更为严谨，强制让该类不能建立对象。
* 可以通过将构造函数私有化完成。
* */
class ArrayTool {
private ArrayTool() {
}
public static int getMax(int[] arr) {
int max = 0;
for (int x = 1; x < arr.length; x++) {
if (arr[x] > arr[max]) {
max = x;
}
}
return arr[max];
}
public static int getMin(int[] arr) {
int min = 0;
for (int x = 1; x < arr.length; x++) {
if (arr[x] < arr[min]) {
min = x;
}
}
return arr[min];
}
public static void selectSort(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
for (int y = x + 1; y < arr.length; y++) {
if (arr[x] > arr[y]) {
swap(arr, x, y);
}
}
}
}
public static void bubblesort(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
for (int y = 0; y < arr.length - x - 1; y++) {
if (arr[y] > arr[y + 1]) {
swap(arr, y, y + 1);
}
}
}
}
private static void swap(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x != arr.length - 1) {
System.out.print(arr[x] + ", ");
} else {
System.out.print(arr[x] + "]\n");
}
}
}
}
public class ArrayToolDemo {
public static void main(String[] args) {
int[] arr = { 1, 3, 9, 4, 2 };
int max = ArrayTool.getMax(arr);
System.out.println("max = " + max); // 9
// ArrayTool tool = new ArrayTool();
/*
* ArrayTool tool = new ArrayTool();
* int max = tool.getMax(arr);
* System.out.println("max = " + max); // 9
* int min = tool.getMin(arr);
* System.out.println("min = " + min); // 1
* tool.printArray(arr); // [1, 3, 9,4, 2]
* tool.selectSort(arr);
* tool.printArray(arr); // [1, 2, 3, 4, 9]
*/
}
}
帮助文档的制作JavaDOC
javadoc -d myhelp -author -version ArrayTool.java
/**
* 接下来，将ArrayTool.class文件发送给其他人，其他人只要将该文件设置到classpath路径下，就可以使用该工具类。
* 但是，很遗憾，该类中到底定义了多少个方法，对方却不清除，因为该类并没有使用说明书。
* 开始制作程序的说明书，Java的说明书通过文档注释来完成。
*/
/**
* 这是一个可以对数组进行操作的工具类，该类中提供了，获取最值，排序等功能。
*
* @author bing
* @version v1.1
*/
public class ArrayTool {
/**
* 空参数构造函数
*/
private ArrayTool() {
}
/**
* 获取一个整型数组中的最大值。
*
* @param arr
* 接收一个int类型的数组
* @return 会返回一个该数组中最大值。
*/
public static int getMax(int[] arr) {
int max = 0;
for (int x = 1; x < arr.length; x++) {
if (arr[x] > arr[max]) {
max = x;
}
}
return arr[max];
}
/**
* 获取一个整型数组中的最小值。
*
* @param arr
* 接收一个int类型的数组
* @return 会返回一个该数组中最小值。
*/
public static int getMin(int[] arr) {
int min = 0;
for (int x = 1; x < arr.length; x++) {
if (arr[x] < arr[min]) {
min = x;
}
}
return arr[min];
}
/**
* 给int数组进行选择排序。
*
* @param arr
* 接收一个int类型的数组
*/
public static void selectSort(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
for (int y = x + 1; y < arr.length; y++) {
if (arr[x] > arr[y]) {
swap(arr, x, y);
}
}
}
}
/**
* 给int数组进行冒泡排序。
*
* @param arr
* 接收一个int类型的数组
*/
public static void bubblesort(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
for (int y = 0; y < arr.length - x - 1; y++) {
if (arr[y] > arr[y + 1]) {
swap(arr, y, y + 1);
}
}
}
}
/**
* 给数组中元素进行位置的置换。
*
* @param arr
* 接收一个int类型的数组
*
* @param a
* 变量换的位置
*
* @param b
* 变量换的位置
*/
private static void swap(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/**
* 用于打印数组中的元素。打印形式是：[elemet1, elemet2, ...]
*/
public static void printArray(int[] arr) {
System.out.print("[");
for (int x = 0; x < arr.length; x++) {
if (x != arr.length - 1) {
System.out.print(arr[x] + ", ");
} else {
System.out.print(arr[x] + "]\n");
}
}
}
}
/*
* 一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致。
* 如果类被public修饰，那么默认的构造函数也带public修饰符。
* 如果类没有被public修饰，那么默认的构造函数，也没有public修饰。
*
* 默认构造函数的权限是随着类的变化而变化的。
*/
静态代码块
/*
* 静态代码块。
* 格式：
* static {
* 静态代码块中的执行语句。
* }
* 特点：随着类的加载而执行，只执行一次，并优先于主函数。
* 用于给类进行初始化的。
* */
class StaticCode {
int num = 9;
public StaticCode() {
System.out.println("b");
}
static {
System.out.println("a");
}
{
System.out.println("c" + this.num);
}
StaticCode(int x) {
System.out.println("d");
}
public static void show() {
System.out.println("show run");
}
}
class StaticCodeDemo {
static {
System.out.println("b");
}
public static void main(String[] args) {
new StaticCode();
new StaticCode();
System.out.println("over");
StaticCode.show();
StaticCode a = null;
a = new StaticCode();
new StaticCode(4);
}
static {
System.out.println("c");
}
}
运行结果
b
c
a
c9
b
c9
b
over
show run
c9
b
c9
d
对象的初始化过程
class Person {
public Person() {
}
private String name = "hah";
private int age;
private static String country = "cn";
Person(String name, int age) {
this.name = name;
this.age = age;
}
{
System.out.println(name + ".." + age);
}
public void setName(String name) {
this.name = name;
}
public void speak() {
System.out.println(this.name + "..." + this.age);
}
public static void showCountry() {
System.out.println("country=" + Person.country);
Person.method();
}
public static void method() {
System.out.println("method run");
}
}
public class PersonDemo {
public static void main(String[] args) {
Person p = new Person("zhangsan", 20);
p.setName("lisi");
new Person();
}
}
/*
* Person p = new Person("zhangsan", 20);
* 该句话都做了什么事情？
* 1. 因为new用到了Person.class文件，所以会先找到Person.class文件并加载到内存中。
* 2. 会执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
* 3. 在堆内存中开辟空间，分配内存地址。
* 4. 在堆内存中建立对象的特有属性，并进行默认初始化。
* 5. 对属性进行显示初始化。
* 6. 对对象进行构造代码块初始化。
* 7. 对对象进行对应的构造函数初始化。
* 8. 将内存地址赋给栈内存中的p变量。
*/
单例设计模式
/*
* 设计模式：解决某一类问题最行之有效的方法。
* Java中23种设计模式：
* 单例设计模式：解决一个类在内存中只存在一个对象。
*
* 想要保证对象唯一。
* 1. 为了避免其他程序过多建立该类对象，先禁止其他程序建立类对象。
* 2. 还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。
* 3. 为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
*
* 这三步怎么用代码体现呢？
* 1. 将构造函数私有化。
* 2. 在类中创建一个本类对象。
* 3. 提供一个方法可以获取该对象。
*
* 对于事物该怎么描述，还怎么描述。
* 当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。
*
* */
class Single {
private int num;
public void setNum(int num) {
this.num = num;
}
public int getNum() {
return num;
}
private Single() {
}
private static Single s = new Single();
public static Single getInstance() {
return s;
}
}
class SingleDemo {
public static void main(String[] args) {
Single ss = Single.getInstance();
System.out.println(ss); // test9.Single@52e922
// Single s1 = new Single();
// Single s2 = new Single();
// s1.setNum(40);
// System.out.println(s2.getNum()); // 0
Single s1 = Single.getInstance();
Single s2 = Single.getInstance();
s1.setNum(23);
System.out.println(s2.getNum()); // 23
// Student s1 = new Student();
// s1.setAge(30);
// Student s2 = new Student();
// s2.setAge(12);
// Student s1 = Student.getInstance();
// Student s2 = Student.getInstance();
}
}
class Student {
private int age;
private Student() {
}
private static Student s = new Student();
public static Student getInstance() {
return s;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
单例设计模式方式二
/*
* 这个是先初始化对象。
* 称为：饿汉式。
*
* Single类一进内存，就已经创建好了对象。
* */
class Single {
private static Single s = new Single();
private Single() {
}
public static Single getInstance() {
return s;
}
}
/*
* 对象是方法被调用时，才初始化，也叫做对象的延时加载。
* 称为：懒汉式。
* Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
* */
class Single {
private static Single s = null;
private Single() {
}
public static Single getInstance() {
if(s==null) {
synchronized(Single.class) {
if (s == null) {
s = new Single();
}
}
}
return s;
}
}
/*
* 记录原则：定义单例，建议使用饿汉式。
* */
228
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
