基础学习day06---面向对象二---static,类的初始化和调用顺序、单例模式

一、static关键字

1.1、static关键字

静态:static
用法:是一个修饰符,用于修饰成员(成员变量,成员函数)
static 修饰的内容,所有对象共享
当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外,还可以被类名.静态成员


package com.day06;
/**
 * 人类
 * @author Administrator
 *静态:static
 *用法:是一个修饰符,用于修饰成员(成员变量,成员函数)
 *static 修饰的内容,所有对象共享
 *当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外,
 *还可以被类名.静态成员
 */
public class Person {
    //属性
    static String country="CN";

    String name;
    public void show(){
        System.out.println(this.name+"  "+this.country);
    }

    public static void main(String[] args) {
        //多个对象使用同一个属性国家
        Person p=new Person();
        Person p1=new Person();
        p.name="张三";
        p1.name="李四";
        p.show();
        p1.show();
        System.out.println(Person.country); //类名.静态成员变量
    }
}

特点:

1.随着类的加载而加载--也就是:静态会随着类的消失而消失,它的生命周期最长。

2.优先于对象存在---

静态是先存在,对象是后存在。

3.被所有对象共享

4.可以直接被类名所调用

1.2、实例变量和类变量的区别

1.存放位置

类变量随着类的加载而加载存在方法区中。

实例变量随着对象的建立而存在于堆内存中。

2.生命周期

类变量生命周期最长,随着类的消失而消失

实例变量生命周期随着对象的消失而消失

1.3、使用注意事项

静态方法只能访问静态成员(静态成员和静态方法)

非静态方法既可以访问静态也可以访问非静态

静态方法中不可以定义this. super关键字

因为静态优先于对象存在,所以静态中不可以出现this

主函数是静态的

静态有利有弊

利处:对对象共享数据进行单独空间的存储,节省内存空间,没有必要每个对象都存储一份

可以直接被类名调用。

弊端:生命周期过长

访问出现局限性。(静态虽好,只能访问静态。)

1.4、主函数是静态的

主 函数:是一个特殊的函数,作为程序的入口,可以被JVM调用

定义:

public :代表差该该函数访问权限是最大的

static:代表主函数随着类的加载就已经存在了。

void:主函数没有具体的返回值。

main():不是关键字,但是是一个特殊的单词,可以被JVM识别。

函数的参数:String[] args--是一个数组,数组中的元素是字符串,字符串类型的数组

主函数是固定格式的,JVM识别。

args:arguments

JVM在调用主函数时,传入的是new String[0]


package com.day06;

public class MainTest {

    public static void main(String[] args) {
        //遍历主函数
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }

    }

}

package com.day06;

public class MainDemo {

    public static void main(String[] args) {
        String [] arr={"张三","李四","王五","赵六","钱七"};
        MainTest.main(arr);
    }

}

结果:

张三
李四
王五
赵六
钱七

1.5、什么时候使用静态

2个方面:

静态修饰的内容有成员变量和函数

什么时候定义静态变量?

当对象在出现共享数据时,该数据被static修饰

对象中的特有数据要定义成非静态,存在于堆内存,对象内部

什么时候定义静态函数
当功能内部没有访问到非静态数据(对象的特有数据)

那么该 功能可以定义成静态

1.6、静态工具类

package com.day06;

/**
 * 建立一个用于操作数组的工具类, 其中包含着常见的对数组操作的函数, 如:最值,排序等。
 *
 * @author Denny
 * @version v1.0
 */
public class ArrayTool {
    /**
     * 为了不让外界创建对象,将构造方法私有化
     * @author Denny
     *
     * @version v1.0
     */
    private ArrayTool() {
    }

    /**
     * 获取整型数组的最大值
     *
     * @param arr
     *            接收一个元素为int 类型的数组
     * @Return 该数组的最大的元素值
     */
    public static int getMax(int[] arr) {
        int maxIndex = 0;
        for (int x = 1; x < arr.length; x++) {
            if (arr[x] > arr[maxIndex])
                maxIndex = x;
        }
        return arr[maxIndex];
    }

    /**
     * 对数组进行选择排序
     *
     * @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);
            }
        }
    }

    // 用于给数组进行元素的位置置换。
    private static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    /**
     * 获取指定的元素在指定数组中的索引
     *
     * @param arr
     *            接收一个元素为int 类型的数组
     * @param key
     *            要找的元素
     * @return 返回该元素第一次出现的位置,如果不存在则返回 -1
     */
    public static int getIndex(int[] arr, int key) {
        for (int x = 0; x < arr.length; x++) {
            if (arr[x] == key)
                return x;
        }
        return -1;
    }
    /**
     * 将int数组转换成字符串,格式是:[e1,e2,...]
     *
     * @param arr
     *            接收一个元素为int类型的数组
     * @return 返回该数组的字符串表现形式
     */
    public static String arrayToString(int[] arr) {
        String str = "[";

        for (int x = 0; x < arr.length; x++) {
            if (x != arr.length - 1)
                str = str + arr[x] + ",";
            else
                str = str + arr[x] + "]";
        }
        return str;
    }
}

使用类名.静态方法

二、静态代码块

2.1、静态代码块

static{

代码块;

}


package com.day06;

/**
 * 静态代码块
 *
 * @author Denny static{ 静态代码块中的语句 }
 *  特点:随着类的加载而执行, 只执行一次 用于给类进行初始化
 *  并优先于主函数
 */
class StaticDemo {

    static {
        System.out.println("static code A");
    }

}
public class StaticCode{
    static {
        System.out.println("static code B");
    }

    static {
        System.out.println("static code C");
    }
    public static void main(String[] args) {

            //2个匿名对象
            new StaticDemo();
            new StaticCode();

    }
}

结果:

static code B
static code C
static code A

只执行一次就不在执行了

三、对象初始化过程

3.1、初始化过程

package com.day06;

/**
 * 静态代码块
 *
 * @author Denny
 * static{ 静态代码块中的语句 }
 * 特点:随着类的加载而执行, 只执行一次 用于给类进行初始化 并优先于主函数
 */
public class StaticCode {
    int num=9;
    public StaticCode() {
        System.out.println("static code A");
    }

    static {
        System.out.println("static code B");
    }

    {
        System.out.println("con code C  "+this.num);
    }

    public StaticCode(int num) {
        System.out.println("con code D");
    }
    public static void show(){
        System.out.println("E");
    }

    public static void main(String[] args) {

        new StaticCode(4);

    }
}
 

结果:

static code B
con code C  9
con code D

四、对象调用成员过程

4.1、初始化过程

1.因为new 用到了类.class,所以会先找到类.class

2.执行该类中的static代码块,如果有的话,给类.class进行初始化

3.堆内存中开辟空间,分配内存地址,

4.在堆内存中建立对象的特有属性,并默认初化成员变量

5.对对象进行显示初始化

6.对对象进行构造代码块初始化

7.对对象进行对应的构造函数初始化。

8.将内存地址赋给内存中的对象变量

五、单例模式

设计模式:对问题行之有效的解决方式,其实,它是一种思想。

单例设计模式解决的问题:就是可以保证一个类在内存中的对象唯一性。
    比如多个程序使用同一个配置信息对象时,就需要保证该对象的唯一性。

如何保证对象唯一性呢?
    1、不允许其他程序用new创建该类对象。
    2、在该类创建一个本类实例。
    3、对外提供一个方法让其他程序可以获取该对象。

步骤:
    1、私有化该类构造函数。
    2、通过new在本类中创建一个本类对象。
    3、定义一个公有的方法,将创建的对象返回。

5.1、饿汉式


package com.day06;
/**
 * 饿汉式
 * @author denny
 *
 */
public class SingleDemo {
    private String name;
    private int age;
    private static SingleDemo singleDemo=new SingleDemo();

    //私有 构造方法
    private SingleDemo(){

    }
    //提供公有的访问
    public static SingleDemo getNewIntance(){
        return singleDemo;
    }

    public static void main(String[] args) {
        SingleDemo s1=SingleDemo.getNewIntance();
        SingleDemo s2=SingleDemo.getNewIntance();
        System.out.println(s1==s2);

    }

}
 

结果:true

5.2、懒汉式


package com.day06;
/**
 * 饿汉式
 * @author denny
 *
 */
public class SingleDemo2 {
    private String name;
    private int age;
    private static SingleDemo2 singleDemo2;

    //私有 构造方法
    private SingleDemo2(){

    }
    //提供公有的访问
    public static SingleDemo2 getNewIntance(){
        if(singleDemo2==null){
            singleDemo2=new SingleDemo2();
        }
        return singleDemo2;
    }

    public static void main(String[] args) {
        SingleDemo2 s1=SingleDemo2.getNewIntance();
        SingleDemo2 s2=SingleDemo2.getNewIntance();
        System.out.println(s1==s2);

    }

}

结果:true

时间: 2024-11-08 00:43:37

基础学习day06---面向对象二---static,类的初始化和调用顺序、单例模式的相关文章

ASP.Net MVC开发基础学习笔记:二、HtmlHelper与扩展方法

一.一个功能强大的页面开发辅助类—HtmlHelper初步了解 1.1 有失必有得 在ASP.Net MVC中微软并没有提供类似服务器端控件那种开发方式,毕竟微软的MVC就是传统的请求处理响应的回归.所以抛弃之前的那种事件响应的模型,抛弃服务器端控件也理所当然. 但是,如果手写Html标签效率又比较低,可重用度比较低.这时,我们该怎样来提高效率呢?首先,经过上篇我们知道可以通过ViewData传递数据,于是我们可以写出以下的Html代码: <input name="UserName&quo

java基础学习总结——线程(二)

永不放弃,一切皆有可能!!! 只为成功找方法,不为失败找借口! java基础学习总结——线程(二) 一.线程的优先级别 线程优先级别的使用范例: 1 package cn.galc.test; 2 3 public class TestThread6 { 4 public static void main(String args[]) { 5 MyThread4 t4 = new MyThread4(); 6 MyThread5 t5 = new MyThread5(); 7 Thread t1

C++基础学习教程(二)

接上一节内容 2.5条件和逻辑 自增和自减操作符 这个主要区别就是在前和后,大多数学习过其他语言的应该都知道.所以,一个程序带过. 示例如下: /************************************************************************* > File Name: list1001_++.cpp > Author: suool_hu > Mail: [email protected] > Created Time: 2014年0

javascript基础学习(十二)

javascript之BOM 学习要点: 屏幕对象 History对象 Location对象 一.屏幕对象 Screen对象是一个由javascript自动创建的对象,该对象的主要作用是描述客户端的显示器的信息. 目前显示器分辨率为800X600或1024X768两种. screen.height:屏幕的高度 screen.width:屏幕的宽度 screen.availHeigh:屏幕的有效高度 screen.availWidth:屏幕的有效宽度 二.History对象 History对象可以

js基础学习笔记(二)

2.1  输出内容(document.write) document.write() 可用于直接向 HTML 输出流写内容.简单的说就是直接在网页中输出内容. 第一种:输出内容用“”括起,直接输出""号内的内容. <script type="text/javascript"> document.write("I love JavaScript!"); //内容用""括起来,""里的内容直接输出.

《Java编程思想》学习01:普通类的初始化加载顺序分析

<Java编程思想>学习01:普通类的初始化加载顺序分析 本文根据控制变量法,分析普通类(没有extends,implement)初始化的加载顺序: 参考<Java编程思想>第五章 源码 StaticClass1类 package com.tyj.study.thinkinjava; /* * *@Description: *@Author:TYJ *@Date: create in 2019/7/9 17:22 */ public class StaticClass1 { { S

Java基础学习笔记十二 类、抽象类、接口作为方法参数和返回值以及常用API

不同修饰符使用细节 常用来修饰类.方法.变量的修饰符 public 权限修饰符,公共访问, 类,方法,成员变量 protected 权限修饰符,受保护访问, 方法,成员变量 默认什么也不写 也是一种权限修饰符,默认访问, 类,方法,成员变量 private 权限修饰符,私有访问, 方法,成员变量 static 静态修饰符 方法,成员变量 final 最终修饰符 类,方法,成员变量,局部变量 abstract 抽象修饰符 类 ,方法 我们编写程序时,权限修饰符一般放于所有修饰符之前,不同的权限修饰

java基础学习_面向对象(上)03_day08总结

==========================================================================================================================================================涉及到的知识点有:0:前面学习通过方法对代码进行改进,为什么要给方法使用静态呢?1:Java如何制作帮助文档(API)(了解)2:通过JDK提供的帮助文档(API)学习了Math类(掌握)3:

Java学习之面向对象二

###01继承的概述 *A:继承的概念 *a:继承描述的是事物之间的所属关系,通过继承可以使多种事物之间形成一种关系体系 *b:在Java中,类的继承是指在一个现有类的基础上去构建一个新的类, 构建出来的新类被称作子类,现有类被称作父类 *B:继承关系的子类特点 *a:子类会自动拥有父类所有非private修饰的属性和方法 ###02继承的定义格式和使用 *A:继承的格式 class 子类 extends 父类 {} *B:雇员(Employee)与研发部员工(Developer)案例: *cn