—————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流!——————————
static关键字
静态:static
用法:是一个修饰符,用于修饰成员(成员变量,成员函数)
当成员被静态所修饰后,就多了一种调用方法,除了可以用被对象调用外,还可以
直接被类名调用
类名.静态成员
特有数据存放在对象,存储在堆内存
static存放在方法区(共享区,数据区)
static特点:
1.随着类的加载而加载(代表随着类的消失而消失,生命周期最长)
2.优先于对象存在
3.被所有对象共享
4.可以被类名直接使用
静态成员变量称为类变量,静态函数称为类方法
实例变量和类变量的区别:
1.存放位置: 类变量随着类的加载就存在于方法区中,
实例变量随着对象的建立而存在堆内存中
2.生命周期: 类变量的生命周期最长,随着类的消失而消失
实例变量生命周期随着对象的消失而消失
静态使用注意事项:
1.静态方法只能访问静态成员,非静态方法能访问静态成员
2.静态方法不可以定义this,super关键字,因为先有类再有对象
2.主函数就是静态的
静态有利有弊:
利:对对象的共享数据进行单独空间的存储,节省空间,没有必要每一个对象中都存储一份,还可以
直接被类名使用
弊: 生命周期长,访问有局限性.
解析main主函数:
主函数: 是一个特殊的函数,作为程序的入口,可以被jvm调用
public static void main(String []args){
}
主函数的定义:
public:代表该函数访问权限最高
static:代表函数是随着类的加载就已经存在了
void:主函数没有具体的返回值
main:不是关键字,可以被jvm识别的特殊单词
String[]args:字符串类型数组
主函数是固定的格式才被jvm识别,只有字符串类型数组名可以改
jvm在调用函数时,传入的new String[0];在调用的时候可以传入参数,
用空格隔开,jvm会自动封装成数组
例子:java 类名 字符串1 字符串2 字符串3
什么时候使用静态:
什么时候定义类变量:
当对象出现共享数据时,非共享数据属性
例如:学生在同一学校 学校就是共享数据
什么时候定义类方法:
当功能内部没有访问到内部非静态数据(对象的特有数据),那么该功能可以定义成静态的
静态的应用: 工具类
每一应用程序都有共性的功能,可将这些功能进行抽取,独立发呆封装,以便使用
虽然可以通过new实体操作这些方法,对数组进行操作时发现了问题:
1.对象时用于封装数据的,可是实体并未封装特有数据
2.操作数组的每一方法都没有用到实体的特有数据
这时,为了让程序更严谨,是不需要对象的,这时可以定义用private私有对象构造函数
制作帮助文档:
//制作时,claspath 路径要在当前运行的目录下
将工具类发送给别人用,对方只要设置classpath即可,但也要看说明书
这就用到了java的文档注释,生成程序说明书
@author 作者
@version 版本
@param 变量名 作用
@return 返回值类型 作用
public,protected权限可以生成java注释文档
在cmd生成的方法:
javadoc -d 目录名 -author -version 类名
-d:就是存放目录 后面接的目录名 没有则新建
作者和版本是可选的.. 类名就是要生成注释的类
一个的默认构造函数根据与该类权限一致,如果被public修饰,那么默认
构造函数就是public的,随着类权限变化而变化
静态代码块
static{
执行语句;
}
特点: 随着类的加载而执行,只执行一次,优先于主函数
即使重新new实体也不会改变,类方法执行,static代码块也会加载
对象初始化过程:
Person p=new Person("track",20);
该语句都做了什么事情呢?
1.因为new用到了Person.class,所以会先找到Person.class并加载到内存中
2.执行该类static代码块,如果有的话,给Person.class进行初始化
3.在堆内存中开辟空间,分配内存地址
4.在堆内存中建立对象的特有属性,并进行默认初始化
5.对属性进行显示初始化
6.对对象进行构造代码块初始化
7.对对象的构造函数进行初始化
8.将内存地址赋给栈内存中的变量(引用)
设计模式
解决某一类问题最有效的方式,java有23中设计模式
单例模式就是其中一种
想要保证对象的唯一:
1.为了避免其他程序过多的建立该类对象,先控制进制其他程序建立该类对象
2.还为了让其他程序可以访问到该类对象,只好在本类中定义一个对象
3.为了方便其他程序对对象的访问,可以对外提供访问方式
用代码实现以上三种步骤:
1.将构造函数私有化
2.在类中定义一个对象 private static
3.提供一个方法可以获取该对象
对于事物怎么描述还是怎么描述,当需要将该事物的对象保证在内存中的唯一
时,就可以加上上诉三步即可.
单例模式有两种方式:
1.饿汉式
2.懒汉式
两种方法的区别:
1.饿汉式:类一进内存就已经初始化对象
2.懒汉式:类进内存,对象还没有存在,只有调用获取实例方法才建立对象.
static关键字
静态:static
用法:是一个修饰符,用于修饰成员(成员变量,成员函数)
当成员被静态所修饰后,就多了一种调用方法,除了可以用被对象调用外,还可以
直接被类名调用
类名.静态成员
特有数据存放在对象,存储在堆内存
static存放在方法区(共享区,数据区)
static特点:
1.随着类的加载而加载(代表随着类的消失而消失,生命周期最长)
2.优先于对象存在
3.被所有对象共享
4.可以被类名直接使用
静态成员变量称为类变量,静态函数称为类方法
实例变量和类变量的区别:
1.存放位置: 类变量随着类的加载就存在于方法区中,
实例变量随着对象的建立而存在堆内存中
2.生命周期: 类变量的生命周期最长,随着类的消失而消失
实例变量生命周期随着对象的消失而消失
静态使用注意事项:
1.静态方法只能访问静态成员,非静态方法能访问静态成员
2.静态方法不可以定义this,super关键字,因为先有类再有对象
2.主函数就是静态的
静态有利有弊:
利:对对象的共享数据进行单独空间的存储,节省空间,没有必要每一个对象中都存储一份,还可以
直接被类名使用
弊: 生命周期长,访问有局限性.
/*
static 关键字
*/
class Demo1
{
public static void main(String[] args)
{
Student.show();//多了种类名直接调用的方式 static代码块执行
new Student().show_1(); //在new static代码块也不会执行了
}
}
class Student
{
{
System.out.println("我是构造代码块,优先于构造函数");
}
public Student(){
System.out.println("构造函数,随着对象的加载而加载");
}
private String name;
private static String schoolName="xx学校";//共享数据
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
static
{
System.out.println("我是static代码块,随着类的加载而加载,我只会被执行一次");
}
/*错误的 类方法不能调用非静态变量
public static void show(){
System.out.println("我叫"+name+"来自"+schoolName);
}
*/
/*类方法只能访问静态变量*/
public static void show(){
System.out.println("静态方法,我来自"+schoolName);
}
/*非静态方式可以访问静态变量*/
public void show_1(){
System.out.println("非静态方法,我来自"+schoolName);
}
}
解析main主函数:
主函数: 是一个特殊的函数,作为程序的入口,可以被jvm调用
public static void main(String []args){
}
主函数的定义:
public:代表该函数访问权限最高
static:代表函数是随着类的加载就已经存在了
void:主函数没有具体的返回值
main:不是关键字,可以被jvm识别的特殊单词
String[]args:字符串类型数组
主函数是固定的格式才被jvm识别,只有字符串类型数组名可以改
jvm在调用函数时,传入的new String[0];在调用的时候可以传入参数,
用空格隔开,jvm会自动封装成数组
/*
主函数测试 给主函数传参 这这是一种方式
*/
class Demo2
{
public static void main(String[] args)
{
String []arr={"a","b","c","d"};
Test.main(arr); //给test主函数传can
}
}
class Test
{
public static void main(String []args){
System.out.println(args.length);
for(int i=0;i<args.length;i++){
System.out.print(args[i]+"\t");
}
}
}
例子:java 类名 字符串1 字符串2 字符串3
什么时候使用静态:
什么时候定义类变量:
当对象出现共享数据时,非共享数据属性
例如:学生在同一学校 学校就是共享数据
什么时候定义类方法:
当功能内部没有访问到内部非静态数据(对象的特有数据),那么该功能可以定义成静态的
静态的应用: 工具类
class Demo3
{
public static void main(String[] args)
{
int []arr={5,4,6,8,15,11,78,55,226,456};
System.out.println(ArrTools.getMax(arr)); //获取最大值
System.out.println(ArrTools.getMin(arr)); //获取最小值
ArrTools.printArr(arr);
// ArrTools.selectSort(arr); //选择排序
ArrTools.bubbleSort(arr);//冒泡排序
ArrTools.printArr(arr);
System.out.println(ArrTools.halfSearch(arr,5)); //位置是1
}
}
/**
static 应用 数组工具类
@author 刘阳文
@version v1.0
*/
public class ArrTools
{
/**
@param arr int型数组
求数组最大值
*/
public static int getMax(int []arr){
int max=0;
for (int i=0;i<arr.length ;i++ )
{
if(arr[i]>arr[max])
max=i;
}
return arr[max];
}
/*求数组中最小值*/
public static int getMin(int []arr){
int min=0;
for(int i=0;i<arr.length;i++){
if(arr[i]<arr[min])
min=i;
}
return arr[min];
}
/*选择排序*/
public static void selectSort(int []arr){
for (int i=0;i<arr.length-1 ;i++ )
for (int j=i+1;j<arr.length-1 ;j++ )
if(arr[i]>arr[j])
swap(arr,i,j);
}
/*冒泡排序*/
public static void bubbleSort(int []arr){
for (int i=0;i<arr.length-1 ;i++ )
for (int j=0;j<arr.length-i-1 ;j++ )
if(arr[j]>arr[j+1])
swap(arr,j,j+1);
}
/*位置交换*/
private static void swap(int arr[],int i,int j){
arr[i]=arr[i]^arr[j];
arr[j]=arr[i]^arr[j];
arr[i]=arr[i]^arr[j];
}
/*打印数组*/
public static void printArr(int []arr){
for(int u : arr)
System.out.print(u+"\t");
}
/*二分查找*/
public static int halfSearch(int []arr,int want){
int min=0,max=arr.length-1,mid;
do
{
mid=(min+max)>>>1;
if(arr[mid]==want)
return mid;
else{
if(arr[mid]<want)
min=mid+1;
else if(arr[mid]>want)
max=mid-1;
else
return mid;
}
}
while (min<=max);
return -1;
}
}
每一应用程序都有共性的功能,可将这些功能进行抽取,独立发呆封装,以便使用
虽然可以通过new实体操作这些方法,对数组进行操作时发现了问题:
1.对象时用于封装数据的,可是实体并未封装特有数据
2.操作数组的每一方法都没有用到实体的特有数据
这时,为了让程序更严谨,是不需要对象的,这时可以定义用private私有对象构造函数
制作帮助文档:
//制作时,claspath 路径要在当前运行的目录下
将工具类发送给别人用,对方只要设置classpath即可,但也要看说明书
这就用到了java的文档注释,生成程序说明书
@author 作者
@version 版本
@param 变量名 作用
@return 返回值类型 作用
public,protected权限可以生成java注释文档
在cmd生成的方法:
javadoc -d 目录名 -author -version 类名
-d:就是存放目录 后面接的目录名 没有则新建
作者和版本是可选的.. 类名就是要生成注释的类
一个的默认构造函数根据与该类权限一致,如果被public修饰,那么默认
构造函数就是public的,随着类权限变化而变化
静态代码块
static{
执行语句;
}
特点: 随着类的加载而执行,只执行一次,优先于主函数
即使重新new实体也不会改变,类方法执行,static代码块也会加载
对象初始化过程:
Person p=new Person("track",20);
该语句都做了什么事情呢?
1.因为new用到了Person.class,所以会先找到Person.class并加载到内存中
2.执行该类static代码块,如果有的话,给Person.class进行初始化
3.在堆内存中开辟空间,分配内存地址
4.在堆内存中建立对象的特有属性,并进行默认初始化
5.对属性进行显示初始化
6.对对象进行构造代码块初始化
7.对对象的构造函数进行初始化
8.将内存地址赋给栈内存中的变量(引用)
设计模式
解决某一类问题最有效的方式,java有23中设计模式
单例模式就是其中一种
想要保证对象的唯一:
1.为了避免其他程序过多的建立该类对象,先控制进制其他程序建立该类对象
2.还为了让其他程序可以访问到该类对象,只好在本类中定义一个对象
3.为了方便其他程序对对象的访问,可以对外提供访问方式
用代码实现以上三种步骤:
1.将构造函数私有化
2.在类中定义一个对象 private static
3.提供一个方法可以获取该对象
对于事物怎么描述还是怎么描述,当需要将该事物的对象保证在内存中的唯一
时,就可以加上上诉三步即可.
单例模式有两种方式:
1.饿汉式
2.懒汉式
两种方法的区别:
1.饿汉式:类一进内存就已经初始化对象
2.懒汉式:类进内存,对象还没有存在,只有调用获取实例方法才建立对象.
简而言之:就是先初始化,后出初始化的问题.
/*单例模式*/
class Demo4
{
public static void main(String[] args)
{
Single s=Single.getInstance();
s.show();
}
}
/*懒汉式
class Single
{
private static Single s=new Single();
private Single(){};
public static Single getInstance(){
return s;
}
public void show(){
System.out.println("我是饿汉式");
}
}
*/
/*饿汉式*/
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;
}
public void show(){
System.out.println("我是懒汉式");
}
}
—————————— ASP.Net+Android+IOS开发、.Net培训、期待与您交流!——————————