Java基础——Static修饰符+静态相关+帮助文档制作+对象初始化_调用成员过程+单例设计
2014-06-29 10:41
1186 查看
一、Static修饰符
String name;//成员变量,实例(对象)变量。Static String name;//静态的成员变量,类变量。
用于修饰成员(变量,函数)
当每个对象都有共性的数据(不是属性)时,可以用Static修饰,此时被修饰的变量数据不在堆内存,被放在共享区(方法区,数据区)对象建立后直接引用该数据。既静态所修饰内容被对象所共享。
当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用,还可以直接被类名调用。类名.静态成员;
1. Static特点:
随着类的加载而加载,消失而消失,说明它的生命周期最长优先于对象的存在
被所有对象共享
静态成员可以直接被类名调用,因此静态成员变量又称为类变量。非静态成员变量又被称为实例变量。
2. 实例变量和类变量的区别:
存放位置:类变量随着类的加载而存在方法区(共享区)中。实例变量随着对象的建立而存在于堆内存中。生命周期:类变量生命周期最长,随着类的消失而消失。实例变量生命周期随着对象的消失而消失。
3. 静态使用注意事项:
静态方法只能访问静态成员,非静态方法既可以访问静态也可以访问非静态。静态方法中不可以定义this,super关键字,因为静态优先于对象存在。
主函数是静态的;
4.静态利弊:
利处:对对象的共享数据开辟单独空间的存储,节省空间,没必要每一个对象中都存储一份;可以直接被类名调用;
弊端:生命周期过长,访问出现局限性(静态虽好,只能访问静态)
二、什么时候使用静态?
两方面下手:静态修饰的内容有成员变量和函数。1. 什么时候定义静态变量(类变量)呢?
当对象中出现共享数据(数据指:具体的值,学校名称属于学生的共享数据)时,该数据被静态所修饰。例如:学生都有自己特有的姓名。对象中特有的数据要定义成非静态存在于堆内存中。
2.什么时候定义静态函数呢?
当功能内部没有访问到非静态数据(对象的特有数据),那么该功能可以定义成静态的。三、静态的应用-工具类
当一个类中创建了另一个类的对象,编译的时候会同时编译两个类文件;
/*
每一个应用程序中都有共性的功能,
可以将这些功能进行抽取,独立封装,以便复用。
虽然
可以通过建立ArrayTool的对象使用这些工具方法,对数组进行操作。
发现问题:
对象是用于封装数据的,可是ArrayTool对象并未封装特有(非公性)数据。
操作数组的每一个方法度没有用到ArrayTool对象中的特有数据。
考虑让程序更严谨,不需要对象。
直接将这些方法定义成静态的,直接通过类名调用即可。
方法都静态后,可以方便于使用,但是该类还是可以被其他程序建立对象的,
为了更为严谨,强制让该类不能建立对象,
可以通过将默认的构造函数私有化完成。
空参数的构造函数不一定是默认构造函数,默认的是看不见的,写了就不是默认的了。
class Demo
{
Demo(){}:当你定义了空参数的构造函数,就不是默认的了,而是自定义构造函数了。
}
*/
1. class ArrayTool//工具类,通常是静态的方法
{private ArrayTool(){};//将默认的构造函数私有化,对方不能建立对象。
//获得最大值
public static int getMax(int[] arr)
{
int max=0;
for(int x=1; x<arr[max];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[min],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]+"]");
}
}
}
2. class ArrayToolDemo //调用工具类的方法
{public static void main(String[] args)
{
int[] arr={3,6,89,43,56};
int max=ArrayTool.getMax(arr);
System.out.println("Max="+max);
//能够创建对象,因为工具类有个默认的空构造函数。只要有属性或行为,就可以创建对象。
/*ArrayTool tool=new ArrayTool();//此对象没必要生成,将工具类的方法改为静态
int max=tool.getMax(arr);
System.out.println("Max="+max);
tool.printArray(arr);
tool.selectSort(arr);
tool.printArray(arr);
*/
}
}
四、主函数
是一个特殊的函数,作为程序的入口,可以被JVM调用。1. 主函数的定义:
Public:代表着该函数的访问权限的最大的。Static :代表着主函数随着类的加载就已经存在了。
Void :主函数没有具体的返回值。
Main :不是关键字,但是是一个特殊的单词,可以被JVM识别。
(String[] args):函数的参数,是一个字符串类型的数组。(arguments)
主函数是固定格式,包括参数(参数名自定义),才能被JVM识别。
数组有两种值:数组和NULL
JVM在调用主函数时,传入的是new string[0]; hiahia
五、帮助文档的制作javadoc
当有工具类.CLASS文件时,只要将该文件设置到class路径下,就可以使用该工具类了。但无法知道定义了多少方法。可以制作程序说明书,通过文档注释,javadoc程序;
识别符:@param等。
在命令行输入
javadoc -d myhelp -author -version ArrayTool.java
D盘自动创建html文件的存放文件夹
需要制作说明文档的类要public修饰,否则不能生成相应的注释;
一个类中默认会有一个空参数的构造函数,权限与所属类一致;
空参数的构造函数不一定是默认构造函数,默认的是看不见的,写了就不是默认的了。
class Demo { Demo(){}:当你定义了空参数的构造函数,就不是默认的了,而是自定义构造函数了。 } */ /** 这是一个可以对数组操作的工具类,提供了获取最值,排序等功能。 @author 杨xx @version v1.1 */ class ArrayTool//工具类,通常是静态的方法 { /** 空参数构造函数。 */ private ArrayTool(){};//将默认的构造函数私有化,对方不能建立对象。 /** 获取一个数组中的最大值 @param arr 接收一个INT类型数组 @return 返回一个该数组中的最大值 */ public static int getMax(int[] arr) { int max=0; for(int x=1; x<arr[max];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[min];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; } /** 打印int数组元素,打印形式是:[elemet 1,elemet2, ...] @param arr 接收一个INT类型数组 */ 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]+"]"); } } }
六、静态代码块
静态代码块。格式:
static
{
静态代码块中的执行语句。
}
特点:随着类的加载而执行,只执行一次,并优先于主函数。
用于给类进行初始化的。
class StaticCode { int num = 9;//非静态成员 StaticCode() { System.out.println("b"); } //静态代码块,给类初始化 static { System.out.println("a");//这里加上NULL,无法编译,因为静态代码块不能访问实例变量; } //构造代码块,给对象初始化 { 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(4);//a c d //new StaticCode();//执行一次 //new StaticCode();//不执行 //System.out.println("over"); //StaticCode.show(); //StaticCode s = null;//没有指向,未加载StaticCode //s = new StaticCode(); //StaticCode.show(); } static { ///System.out.println("c"); } }
//d:\>java0217\day06>java StaticCodeDemo
//b c a over
七、对象的初始化过程
class Person { private Person(){} private String name = "hah";//,先默认初始化null,然后输出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"); } } class PersonDemo { public static void main(String[] args) { Person p = new Person("zhangsan",20); p.setName("lisi"); new Person(); } } <span style="font-family:Calibri;font-size:14px;">Person p = new Person("zhangsan",20);</span>
该句话都做了什么事情?
1,
因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2,
执行该类中的static代码块,如果有的话,给Person.class类进行初始化。
3,在堆内存中开辟空间,分配内存地址。
4,在堆内存中建立对象的特有属性。并进行默认初始化(NULL,0)。
5,对属性进行显示初始化。(给属性赋值的时候)
6,对对象进行构造代码块初始化。
7,对对象进行对应的构造函数初始化。
8,将内存地址赋给栈内存中的p变量。
八、对象调用成员过程
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
对象调用非静态成员时访问堆内存,调用静态成员是没有访问堆内存;
静态成员调用静态成员,前面省略了类名.
九、单例设计模式(饿汉士)
设计模式:解决某一类问题最行之有效的方法。
java中23种设计模式:
单例设计模式:解决一个类在内存只存在一个对象。
想要保证对象唯一。
1,为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2,还为了让其他程序可以访问到该类对象,只好在本类中,自定义一个对象。
3,为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式。
这三部怎么用代码体现呢?
1,将构造函数私有化。
2,在类中创建一个本类对象。
3,提供一个方法可以获取到该对象。
对于事物该怎么描述,还怎么描述。
当需要将该事物的对象保证在内存中唯一时,就将以上的三步加上即可。
class Single { private Single(){} private static Single s = new Single(); public static Single getInstance() { return s; } } class SingleDemo { public static void main(String[] args) { Single s1 = Single.getInstance(); Single s2 = Single.getInstance(); s1.setNum(23); System.out.println(s2.getNum()); // Single s1 = new Single();//没有将构造代码块私有化时可以NEW 新对象,对象间互不影响 // Single s2= new Single(); // s1.setNum(30); // System.out.println(s2.getNum()); // Student s1 = new Student(); // s1.setAge(30); // // Student s2 = new Student(); // s2.setAge(12); Student s1 = Student.getStudent(); Student s2 = Student.getStudent(); } } class Student { private int age; private static Student s = new Student(); private Student(){} public static Student getStudent() { 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) //假设两个对象A,B;-->A,-->B(CPU处理是急速的轮流切换的,即A执行这条语句后B接着执行) { synchronized(Single.class)//A加锁,B进不来,保证只生成一个对象,也降低了加载锁的次数 { if(s==null) s = new Single(); } } return s; } } //记住原则:定义单例,建议使用饿汉式。 class { public static void main(String[] args) { System.out.println("Hello World!"); } }
相关文章推荐
- 制作程序文档_主函数_静态代码块_对象的初始化过程_对象调用成员过程
- 黑马程序员_Java基础_面向对象(Static的使用、对象初始化和调用成员过程、单例设计模式)
- day06static关键字,main函数,帮助文档的制作,静态代码块,对象的初始化过程,单例设计模式
- 黑马程序员_day06 面向对象(静态,对象的初始化和对象调用成员过程,单例设计模式)
- 黑马程序员——Java基础---面向对象(对象的初始化、对象调用成员、单例设计模式)(4)
- 黑马程序员——java第六天:面向对象(静态、帮助文档、对象初始化过程、单例)
- Java重修之路(七)面向对象之静态,主函数,Doc文档,静态代码块,对象初始化过程,单例设计模式
- 面对对象2【static】【主函数】【静态应用】【Java帮助文档】【静态代码块】【对象初始化过程】
- java 程序加载过程---3--类中申明同时申明类的静态对象 创建类的实例 访问类的静态变量 调用类的静态方法 使用反射方法 初始化类的子类对象 直接使用java.exe 调用某个类
- 黑马程序员 笔记(六)——面向对象(static关键字、静态、main函数、、帮助文档、对象的调用和初始化、单例)
- C++转Java自学之路(四)文档注释、静态代码块与对象初始化过程
- JAVA基础知识再学习(2)对象的初始化过程 & 对象的调用过程
- 黑马程序员——Java基础---面向对象(面向对象,类,对象,匿名对象,封装,构造函数,构造代码块,this,static,main,帮助文档,静态代码块,单例)
- 黑马程序员--03.Java面向对象--04.【对象初始化的过程】【对象调用成员的过程】
- 黑马程序员_Java基础[10]_主函数main、数组、static、静态代码块、帮助文档
- 图解Java对象初始化过程以及方法调用
- java中对象多态时成员变量,普通成员函数及静态成员函数的调用情况
- java程序在执行过程中,类,对象以及它们成员加载、初始化的顺序如下:
- 黑马程序员_java入门_帮助文档的制作和静态代码块
- 黑马程序员_静态方法,java文档制作和单例设计模式