- 浏览: 1588628 次
- 来自: 上海
文章分类
- 全部博客 (374)
- Java (101)
- Struts (54)
- Oracle (30)
- JavaScript (16)
- Spring (27)
- Hibernate (16)
- MyEclipse (3)
- JSF (1)
- FreeMarker (2)
- SiteMesh (2)
- JfreeChart (2)
- Ibatis (2)
- JSP (12)
- MyBatis (4)
- SWFupload (1)
- EJB (4)
- Jboss (4)
- WebService (2)
- Linux (16)
- Android (2)
- XML (6)
- Java 网络编程 (13)
- AXIS2 (1)
- FTP (1)
- Jswing (1)
- Socket (3)
- 杂文选集 (6)
- solr (2)
- PS (1)
- Tomcat (7)
- JDBC (9)
- Highcharts (1)
- maven (1)
- Nodejs (0)
- navicat (2)
- Exception (5)
- eclipse (3)
- jQuery (1)
- springMVC (4)
- MySQL (11)
- SVN (1)
- Sql Server (1)
- zookeeper (1)
- JVM (1)
- Groovy (2)
- Git (1)
- Nginx (1)
- DynamicReport (1)
- IDEA (2)
- JasperReports (1)
- Postgresql (2)
- Mac (1)
- gradle (1)
- 数据结构算法 (1)
最新评论
-
hpu145:
引用引用
java 千分位的添加和去除 -
被遗忘的下路:
少了个junit-4.8.2的包
SSH2整合完整案例(四十三) -
白天看黑夜:
java过滤emoji字符处理,希望能帮到你http://ww ...
emoji 表情图片解决方法 -
caipeiming:
这个挺好JavaScript实现input输入框控件只允许输入 ...
js 控制文本框只能输入中文、英文、数字等 -
双子树:
东西太好啦受教啊
Struts2 JSP中将list,set ,Map传递到Action然后<s:iterator>遍历(三十五)
static(静态) 关键字
static 的使用 为了节约内存的使用 (如果多个对象拥有同样的属性)
帮助文档的制作
静态代码快
//例子2
//静态代码 和 构造代码块的区别
练习
this 和super 的使用
//对象的初始化过程
对象调用成员的过程
单例设计模式 GOF (Gang of Four)四人帮
//单例的第二种方式
//用于修饰成员(成员变量和成员函数) //被static修饰后的特点 1.随着类的加载而加载,消失而消失(说明生命周期随着类) 2.优先于对象存在 3.被所有对象共享 4.可以直接被类名调用 5.静态变量定义多了,就会消耗更多的内存 //实例变量 和 类变量(静态变量)的区别 1.存放位置 类变量随着类的加载而存在方法区中 实例变量随着对象的建立存在与堆内存中 2.生命周期 类变量的生命周期最长: 随着类的消失而消失 实例变量生命周期随着对象的消失而消失 //使用注意 1.静态方法只能访问静态成员(方法和变量) 非静态可以访问静态也可以访问非静态 2.静态方法中不可以写 this,super 关键字 因为静态优先于对象存在,所以静态方法中不可以出现this. 3.主函数是静态的. //静态有利有弊 利: 对对象共享数据进行单独空间的存储,节省空间,没有必要每个对象中都存储一份. 可以直接被类名调用. 弊端:生命周期过长 访问出现局限性(静态虽好,只能访问静态)
static 的使用 为了节约内存的使用 (如果多个对象拥有同样的属性)
class Person{ String name; //成员变量,实例变量 static String country="CN"; //静态的成员变量,类变量 public void show(){ System.out.println(name+":::"+country); } } /** 主函数: 是一个的特殊的函数,作为程序的入口,可以被JVM调用 主函数的定义: public: 代表着该函数访问权限是最大的. static: 代表着主函数随着类的加载 就已经存在了. void: 主函数没有具体的返回值. main: 不是关键字,但是是一个特殊的单词,可以JVM识别 String[] args: 函数的类型,参数类型是一个数组,该数组中的元素是一个字符串,字符串类型的数组. 主函数是固定格式的:JVM识别. args:arguments : 就只有这个变量名可以 修改 JVM再调用主函数时, 传入的是new String[0]; */ public static void main(String[] args){ } //重载 public static void main(int x){} //重载 public static void main(String[] args,int x){ } DOS 中 给 main传递 参数 c:\> javac MainDemo.java c:\> java MainDemo haha hehe heihei xixi wuwu //还一种 给main传递参数 class MainDemo{ public static void main(String[] args){ String [] arr={"hah","hehe","heihei","xixi","wuwu","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]); } }
//什么时候使用静态?? 要从两方面下手 因为静态修饰的内容有成员变量和函数 //什么时候定义静态的变量(类变量)呢? 当对象中出现共享数据时, 该数据被静态所修饰 存在方法区中. 对象中的特有数据要定义成非静态存在于堆内存中 //什么时候定义静态的函数呢? 当功能内部没有访问到非静态数据(对象的特有数据) 那么该功能可以定义成静态的. //静态的应用 //对象是用来封装数据的,如果某个方法没有使用到 对象中的特有数据,就可以定义成static的 //为了是某个类不然用户建立对象, 可以见构造函数私有化 . /** 一个类中默认会有一个空参数的构造函数 这个默认的构造函数的权限恶化所属类一致. 1.如果类的被public 修饰,那么默认的构造函数,也带有public 修饰符 2.如果类没有被public修饰,那么默认的构造函数,也没有public修饰. 默认的构造函数的权限是随着类的变化而变化的 */
帮助文档的制作
/使用 javadoc 来创建java类的说明书 c:\> javadoc -d c:\javadoc -author -version MyTools.java 在c:\javadoc 中 创建 MyTools工具类的 说明书 //注意 : 要生成说明书的类必须 是public 修饰 /** * 自定义 数组的 和 进制转换 工具类 * @author Bin * @version V1.1 */ public class MyTools { private MyTools() { } /** * 获取最大值 采用 元素值表示 * * @param arr * 接受一个int 类型的数组 * @return 返回该数组中的最大值 */ public static int getArrMax(int[] arr) { int max = arr[0]; for (int x = 0; x < arr.length; x++) { if (arr[x] > max) max = arr[x]; } return max; } /** * 获取数组的最小值 * * @param arr * @return */ public static int getArrMin(int[] arr) { int max = 0; for (int x = 0; x < arr.length; x++) { if (arr[x] < arr[max]) max = x; } return arr[max]; } /** * 选择排序 * * @param arr */ public static void selSort(int[] arr) { for (int x = 0; x < arr.length; x++) { for (int y = x; y < arr.length; y++) { if (arr[x] < arr[y]) { int temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } } } } /** * 冒泡排序 * * @param arr */ public static void bubbleSort(int[] arr) { for (int x = 0; x < arr.length - 1; x++) { // -x:让每一次比较的元素减少,-1 :不让下标越界 for (int y = 0; y < arr.length - 1 - x; y++) { if (arr[y] > arr[y + 1]) { swarp(arr, y, y + 1); } } } } /** * 交换数组中的两个位置 * * @param arr * 接受一个int类型的数组 * @param a * 要换的位置1 * @param b * 要换的位置2 */ private static void swarp(int arr[], int a, int b) { /* * //方法一: int temp=arr[a]; arr[a]=arr[b]; arr[b]=temp; */ // 方法二 arr[a] = arr[a] ^ arr[b]; arr[b] = arr[a] ^ arr[b]; arr[a] = arr[a] ^ arr[b]; } /** * 获取key 第一次出现的位置 -1 表示数组中不存在 * * @param arr * @param key * @return */ public static int getIndex(int[] arr, int key) { for (int x = 0; x < arr.length; x++) { if (arr[x] == key) return x; } return -1;// 没有找到 } /** * 折半查找 必须保证数据中的元素是有序的 折半查找方式1,提高效率,但是必须要保证该数组是有序的数组 * * @param arr * @param key * @return */ public static int halfSearch(int[] arr, int key) { int min = 0; int max = arr.length - 1; int mid = (max + min) / 2; while (arr[mid] != key) { if (key > arr[mid]) min = mid + 1; else if (key < arr[mid]) max = mid - 1; if (min > max) return -1; mid = (max + min) / 2; } return mid; } /** * 折半查找 2 折半查找方式可以用于插入 数据 */ public static int halfSearch_2(int[] arr, int key) { int min = 0, max = arr.length, mid; while (min <= max) { mid = (min + max) >> 1; if (key > arr[mid]) min = mid + 1; else if (key < arr[mid]) max = mid - 1; else return mid; } return -1; } /** * 各种进制的转换 * * @param num * @param base * 与上的基数 * @param offset * 偏移量 * @return */ private static String trans(int num, int base, int offset) { char[] chs = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' }; if (num == 0) return "0"; StringBuffer sb = new StringBuffer(); while (num != 0) { int temp = num & base; sb.append(chs[temp]); num = num >>> offset; } return sb.reverse().toString(); } /** * 十进制 -->二进制 * * @param num * @return */ public static String toBinary(int num) { return trans(num, 1, 1); } /** * 十进制 -->八进制 * * @param num * 十进制数 * @return */ public static String toEight(int num) { return trans(num, 7, 3); } /** * 十进制 -->十六进制 * * @param num * @return */ public static String toHex(int num) { return trans(num, 15, 4); } }
静态代码快
//格式 static{ } //特点 //随着类的加载而执行,只执行一次,用于给类进行初始化的. class StaticCode{ static{ System.out.println("a"); } 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"); } static { System.out.println("c"); } } //输出 为 b c a over
//例子2
class StaticCode{ int num=0; //构造代码块 { System.out.println("e"+this.num); } //构造方法 StaticCode(){} //构造方法 StaticCode(int x){ this.num=9 System.out.println(this.num); } //静态代码块 static{ System.out.println("a"); } } class StaticCodeDemo{ static { System.out.println("b"); } public static void main(String[] args){ StaticCode s=null;// } static { System.out.println("c"); } } //只会输出 bc class StaticCodeDemo{ static { System.out.println("b"); } public static void main(String[] args){ StaticCode s=new StaticCode(); } static { System.out.println("c"); } } //输出 b c a e0 9
//静态代码 和 构造代码块的区别
静态代码: 只有 程序应用到类的数据的时候 ,即 只要类被加载到内存中个 静态代码就会被执行 构造代码快:主要是在 创建对象的时候 首先被调用 优先于构造函数.
练习
class Fu{ static{ //静态代码块 只要该类被JVM 加载到内存 就会运行这个 里面的内容 System.out.println("fu static run"); } { //构造代码块 在所有 构造函数前都会运行 ,除非不用构造函数 System.out.println("fu gouzao run"); } Fu(){ System.out.println("fu run"); } Fu(int x){ //如果不调用该类中的这个构造方法 就不会被运行 System.out.println("fu run"+x); } } class Zi extends Fu{ static{ System.out.println("zi static run"); } { System.out.println("zi gouzao run"); } Zi(){ //super(); 默认都有 这行 System.out.println("zi run"); } Zi(int x){ //super(); 默认都有 这行 System.out.println("zi run"+x); } } public class day7_T1 { public static void main(String[] args) { Zi z=new Zi(4); /* fu static run zi static run fu gouzao run fu run zi gouzao run zi run4 */ } }
this 和super 的使用
class Person{ String name; //默认为0 //Perseon(){} 显示写出 默认构造函数 Person(String name){ //发现 我们没有写 那个默认的构造函数 this.name=name; System.out.println("fu run"+this.name); } } class Student extends Person{ Student(){ super("xx"); //如果没有写父类默认构造函数 ,只能调用 其他构造函数 System.out.println("zi run"); } Student(String name){ this(); //调用子类自己的 默认构造函数 由于 上面的构造函数 中调用 super("xx") 所以这句话可以了 //super(); // 发现 写了this()后 这句报错了, 因为 super 要在第一行 //this(); //发现 先写 super后 在写 this() 也不行 因为 构造函数中 只能调用一次 父类构造方法 ,而且 super要放在第一行 ,所以这两个不能同时出现 System.out.println("zi run" +this.name); //如果不调用父类的构造函数 我们就拿不到这个值了. } } public class day7_T2 { public static void main(String[] args) { Student stu=new Student("aa"); } }
//对象的初始化过程
class Person{ private String name="haha"; pirvate int age; Person(){} Person(String name,int age){ this.name=name; this.age=age; } { this.name="xixi"; this.age="10"; } public static void main(String [] args){ Person p=new Person(); /***这句话做了什么事情 1. 因为 new 用到了Persion.class 所以会先找到Person.class 文件并加载到内存中 2.执行该类中的static 代码快, 如果有的话,给Person.class类进行初始化 3.在栈内存中 分配存储空间 个p,在堆内存中开辟空间,分配内存地址. 4.然后再在堆内存中建立对象,特有的属性, 并进行默认的初始化 5.然后对属性进行 显示初始化 6.然后对对象进行构造代码快初始化 7.对对象进行对应构造函数初始化 8.将内存地址值复制给栈内存中的变量 p */ } }
对象调用成员的过程
package com.itheima.day6; public class Person { private static String country = "cn"; private String name; private int age; public Person(String name, int age) { super(); this.name = name; this.age = age; } private void speak(){ System.out.println(this.name+"...."+this.age); } public static void showCountry(){ System.out.println("country="+country); } /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Person p = new Person("xixi",10); p.setName("lisi"); //运行有 栈内存的变量会被释放 Person p1 = new Person("xixi",10); p1.setName("hah"); } 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; } }
单例设计模式 GOF (Gang of Four)四人帮
java23种设计模式 //设计模式:解决某一类问题最行之有效的方法 //单例设计模式: 解决一个类在内存中只存在一个对象. /** 1.为了避免其他程序过多的创建该类对象,先禁止其他程序建立该类对象 2.为了让其他程序可以访问到该类对象,只好 在本类中,自定义一个对象 给其他程序使用,自己控制要创建的对象个数 3.为了方便其他程序使用自定义的该类对象, 可以对外提供一些访问方式 //程序代码的实现 1.将构造函数苏私有化 2. 在类中创建一个本类的对象 3.提供 一个方法可以获取到该对象. 4.该类的一些属性 该怎么样描述的还是 同样的要描述 */ //类被加载 就初始化了 //称为 :饿汉式 (立即加载) 这个安全点 class Single{ private int age; private void setAge(int age){ this.age=age; } pirvate int getAge(){ return this.age; } private Single(){} //私有化后 其他程序就不能创建对象了 private static Single s=new Single(); //由于 getInstance 中只能使用static 的成员 ,所以只能是 static的了. 由于不能被外界访问 所以只能是 private public static Single getInstance(){ //由于 不能创建对象 所有只能是 static ,由于要被外界访问 所以采用 public 修饰 return s; } } class SingleDemo{ public static void main(String [] args){ Single s1=Single.getInstance(); s1.setAge(13); Single s2=Single.getInstance(); System.out.println(s2.getAge); //13 } }
//单例的第二种方式
//称为 ; 懒汉式 (延迟加载) 效率低 class Single{ private int age; private void setAge(int age){ this.age=age; } pirvate int getAge(){ return this.age; } private Single(){} //私有化后 其他程序就不能创建对象了 private static Single s=null; //由于 getInstance 中只能使用static 的成员 ,所以只能是 static的了. 由于不能被外界访问 所以只能是 private //注意两个 地方 synchronized 不是同时出现的 public static /*synchronized*/ Single getInstance(){ //由于 不能创建对象 所有只能是 static ,由于要被外界访问 所以采用 public 修饰 if(s==null){ synchronized(Single.class){ if(s==null) s=new Single(); } } return s; } } class SingleDemo{ public static void main(String [] args){ Single s1=Single.getInstance(); s1.setAge(13); Single s2=Single.getInstance(); System.out.println(s2.getAge); //13 } } // 只有调用 getInstance 方法后 才被延迟加载.
相关推荐
单例模式是软件设计模式中的一个经典模式,它在Java编程中被广泛应用。单例模式的核心思想是确保一个类只有一个实例,并提供一个全局访问点,以便在整个系统中其他部分可以共享这个唯一实例。这种模式有助于资源的...
单例模式是软件设计模式中的一种,它保证一...在实际开发中,应谨慎使用单例模式,避免过度使用导致代码维护难度增加。在某些场景下,如依赖注入和微服务架构中,可能需要避免使用单例,以保持更好的灵活性和可测试性。
单例模式是软件设计模式中的一种经典模式,它在Java编程中被广泛使用,尤其是在需要控制实例化过程,或者确保某类只有一个实例时。本文将深入探讨Java中的单例模式,帮助你理解其原理和应用。 单例模式的核心思想是...
### Java之单例模式 #### 一、单例模式简介 单例模式是设计模式中较为常见的一种,它确保一个类只有一个实例,并提供一个全局访问点。这种模式在实际开发中有着广泛的应用场景,比如系统配置管理、日志对象、...
6.建造者模式结合单例 当单例对象需要有复杂的构建过程时,可以结合建造者模式使用: ```java public class Singleton { private static Singleton instance; private Builder builder; private Singleton...
Java设计模式中的单例模式是一种常用的创建型设计模式,它保证了类只有一个实例,并提供一个全局访问点。这种模式在很多场景下非常有用,比如控制共享资源、管理配置信息等。接下来,我们将深入探讨8种不同的单例...
其中,单例模式(Singleton Pattern)作为最简单的设计模式之一,旨在确保一个类只有一个实例,并提供一个全局访问点。尽管有些设计模式专家认为它过于简单而不能称为真正的“模式”,但单例模式因其简洁性和实用性...
在Qt的Qml环境中,单例模式是一种设计模式,它允许在整个应用程序中创建一个全局访问点,确保某个类只有一个实例存在。这样的设计模式在需要共享数据或者服务时非常有用,避免了多处创建相同对象导致的数据不一致或...
本资料主要介绍了Java语言中实现单例模式的五种常见方法。 1. 饿汉式(静态常量): 这是最简单的单例模式实现方式,它在类加载时就完成了初始化,所以是线程安全的。代码如下: ```java public class Singleton {...
在Java或其他面向对象语言中,单例模式的实现有多种方式。 1. 饿汉式(静态常量): 这是最简单的单例实现方式,它在类加载时就完成了初始化,所以类加载比较慢,但获取单例的速度快,且线程安全。 ```java ...
单例模式是软件设计模式中的一种,它的主要目的是确保一个类只有一个实例,并提供一个全局访问点。这种模式在很多场景下都非常有用,比如控制服务的唯一性、避免资源浪费等。接下来,我们将深入探讨几种常见的单例...
单例模式是软件开发中一种非常重要的设计模式,它确保一个类只有一个实例,并提供一个全局访问点。在JavaScript这样的动态语言中,单例模式的实现方式很多样,而且可以非常灵活。下面,我们就来深入探讨单例模式在...
QT静态单例管理信号和槽是Qt框架中一种常见的设计模式,用于确保应用程序中只有一个特定类的实例。在Qt编程中,单例模式通常用于管理全局资源,如数据库连接、配置文件读取或系统设置。这里我们将深入探讨如何在Qt中...
单例模式是软件设计模式中的一种,它的主要目的是确保一个类只有一个实例,并提供一个全局访问点。这种模式在很多场景下都非常有用,比如控制数据库连接、日志系统或者配置管理等,因为这些都需要一个全局共享的对象...
单例设计模式是一种在软件工程中广泛使用的设计模式,它保证了一个类只有一个实例,并提供一个全局访问点。这种模式在需要频繁创建和销毁对象,且对象创建代价较大,或者需要共享资源的情况下非常适用,比如线程池、...
理解并掌握这些单例模式的实现方式,有助于我们在实际开发中根据具体需求选择最合适的单例实现,提升代码的效率和质量。同时,单例模式也常常与其他设计模式结合使用,如工厂模式、建造者模式等,以解决更复杂的问题...
使用枚举类型可以实现一种更安全的单例模式,防止外部代码直接访问单例的构造函数。 ```cpp enum class Singleton { Instance, Private = sizeof(Singleton) }; struct SingletonImpl { SingletonImpl() {} ...
Java单例模式是一种设计模式,它保证一个类只有一个实例,并提供一个全局访问点。这个模式在许多场景下非常有用,比如管理共享资源、配置对象或者创建昂贵的对象时。本小程序就是为了帮助开发者快速理解和掌握Java中...