[Java视频笔记]day06

最新推荐文章于 2024-04-22 03:13:09 发布

同学少年

最新推荐文章于 2024-04-22 03:13:09 发布

阅读量848

点赞数

分类专栏： Java_视频笔记

本文链接：https://blog.csdn.net/sr_19930829/article/details/50597127

版权

Java_视频笔记专栏收录该内容

27 篇文章 0 订阅

订阅专栏

静态：static

用法：是一个修饰符用于修饰成员（成员变量，成员函数）,修饰的内容被对象所共享。

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。写法格式：类名.静态成员

class Person
{
	String name;
	static String country = "CN";
	public void show()
	{
		System.out.println(name+" "+country);
	}
}

class day06 
{
	public static void main(String[] args) 
	{
	    Person p = new Person();
		//p.name = "sr";
		//p.show();
		System.out.println(p.country);//有对象
		System.out.println(Person.country);//没有对象，被类名调用
		
	}
}

特有内容随着不同的对象存储，比如name，在堆内存中

static特点：

1.随着类的加载而加载(也就是说，静态会随着类的消失而消失，说明它的生命周期最长)

String name;//成员变量，实例变量

static String country = “CN”;//静态的成员变量，类变量。

2.优先于对象存在

明确一点：静态是先存在，对象是后存在的。

3.被所有对象所共享

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

实例变量和类变量的区别：

1：存放位置：类变量随着类的加载而存在于方法区（共享区）中。实例变量随着对象的建立而存在于堆内存中。

2：生命周期：类变量生命周期最长，随着类的消失而消失。实例变量生命周期随着对象的消失而消失。

静态使用注意事项：

1.静态方法只能访问静态成员。非静态方法既可以访问静态也可以访问非静态。

2.静态方法中不可以定义this,super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this。

3.主函数是静态的.

静态有利有弊：

利处：对对象的共享数据进行单独空间的存储，节省内存空间，没有必要每一个对象中都存储一份。可以直接被类名调用。

弊端：生命周期过长，访问出现局限性（静态虽好，但只能访问静态）.

public static void main(String[] args)

主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。

主函数的定义：

public：代表着该函数的访问权限是最大的

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

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

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

函数的参数：(String[] args)类型为是一个数组，数组中的元素是字符串，称为字符串型数组。

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

public static void main(String[] args)

{

}

public static void main(int x)

{

}

函数重载，可以编译通过，但JVM只执行第一个，固定格式的主函数。参数String[] args中的args可以换成别的，数组名。

JVM在调用主函数时，传入的是newString[0]

什么时候使用静态？

要从两方面下手，因为静态修饰的内容有成员变量和函数。

什么时候定义静态变量（类变量）呢？

当对象中出现了共享数据（String name是共享属性，”sr”是共享数据，它是一个值）,该数据被静态所修饰。对象中的特有数据要定义成非静态存在于堆内存中。

什么时候定义静态函数呢？

当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以被静态所修饰.

class Person
{
	String name;
	public static void show()
	{
		System.out.println("srr");
	}
}
Person.show();

静态的应用:每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便使用。

class ArrayTool
{
	public 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 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 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 void swap(int[] arr, int a, int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] =temp;
	}

	public void printArray(int[] arr)
	{
		for(int i = 0; i < arr.length; ++i)
		{
			if(i != arr.length - 1)
				System.out.print(arr[i]+" ");
			else
				System.out.println(arr[i]);
		}
	}
}

class day06 
{
	public static void main(String[] args)
	{
		int[] arr = {2, 1, 3, 6, 4};
		ArrayTool tool = new ArrayTool();
		int max = tool.getMax(arr);
		System.out.println(max);
		tool.selectSort(arr);
		tool.printArray(arr);
	}
}

虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。

发现了问题：

1.对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。

2.操作对象的每一个方法都没有用到ArayTool对象中的特有数据。

这时就可以考虑，让程序更严谨，是不需要对象的。可以将ArrayTool中的方法都定义为static的，直接通过类名调用即可.

class 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 swap(int[] arr, int a, int b)
	{
		int temp = arr[a];
		arr[a] = arr[b];
		arr[b] =temp;
	}

	public static void printArray(int[] arr)
	{
		for(int i = 0; i < arr.length; ++i)
		{
			if(i != arr.length - 1)
				System.out.print(arr[i]+" ");
			else
				System.out.println(arr[i]);
		}
	}
}

class day06 
{
	public static void main(String[] args)
	{
		int[] arr = {2, 1, 3, 6, 4};
		//ArrayTool tool = new ArrayTool();
		//int max = tool.getMax(arr);
		//System.out.println(max);
		//tool.selectSort(arr);
		//tool.printArray(arr);
		int max = ArrayTool.getMax(arr);
		System.out.println(max);
		ArrayTool.selectSort(arr);
		ArrayTool.printArray(arr);
	}
}

将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。为了更加严谨，强制该类不能建立对象，可以通过将构造函数私有化完成。

class ArrayTool
{
	private ArrayTool(){}
…….
}

接下来，将ArrayTool.class 文件发送给别人，其他人只要把该文件设置到classpath路径下，就可以使用该工具类。但是，很遗憾，该类中到底定义了多少个方法，对方不清楚，因为该类并没有使用说明书。

开始制作程序的说明书，java的说明书通过文档注释来完成。

一个类中默认会有一个空参数的构造函数。这个默认的构造函数的权限和所属类一致。如果类被public修饰，那么默认的构造函数也带public修饰符，如果类没有被public修饰，那么默认的构造函数，也没有public修饰。

默认构造函数的权限是随着类的变化而变化的。

文档注释的格式

/**
这是一个可以对数组进行操作的工具类，该类中提供了
获取最值，排序等功能
@author sr
@version v1.1
*/
public class ArrayTool  //文档要使用Public
{
	/**
	空参数构造函数
	*/
	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);
				}
			}
		}
	}

    /**
	给数组中元素进行位置的置换
	@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;
	}

	/**
	用于打印数组中的元素，打印形式为 elem elem  elem
	*/
	public static void printArray(int[] arr)
	{
		for(int i = 0; i < arr.length; ++i)
		{
			if(i != arr.length - 1)
				System.out.print(arr[i]+" ");
			else
				System.out.println(arr[i]);
		}
	}
}

控制台输入：C:\ 2016winter\java_day06>javadoc -d d:\myhelp -author –version ArrayTool.java

C:\ 2016winter\java_day06为源文件.java所在的位置

d:\myhelp 是把生成的帮助文档放在D盘的myhelp目录下，如果不存在自动创建该目录

ArrayTool.java 为源文件

public class ArrayTool 注意该类一定要用public

注释文档以网页形式生成在d:\myhelp目录下，点击index.html 就可以查看注释文档了。

API Application Programming Interface

静态代码块

格式：

static

{

静态代码块中的执行语句

}

特点：随着类的加载而执行，且只执行一次，并优先于主函数.

用于给类进行初始化，相对少用。

class StaticCode
{
	static
	{
		System.out.println("a");
	}
}


class day06 
{
	static
	{
		System.out.println("b");
	}
	public static void main(String[] args)
	{
		new StaticCode();
		new StaticCode();//不执行了
		System.out.println("over");
	}
	static
	{
		System.out.println("c");
	}
}

运行结果：

over

StaticCode s = null; // 类没有加载

s = new StaticCode(); //类加载了

class StaticCode
{
	int num = 9;
	StaticCode()
	{
		System.out.println("b");
	}

	//构造代码块，给对象初始化，比构造函数优先级高
	{
		System.out.println("c");//可以访问num
	}

	//静态代码块，给类初始化
	static  
	{
		System.out.println("a");//不能访问num变量
	}

	//构造函数，给对应对象初始化
	StaticCode(int x)
	{
		System.out.println("d");
	}
	public static void show()
	{
		System.out.println("run");
	}

}


class day06 
{
	public static void main(String[] args)
	{
		new StaticCode(4);
	}
}

输出：

对象的初始化过程

Person p = new Person(“zhang”,20)；

该句话都做了什么事情？

1.因为new用到了Person.class，所以会找到Person.class文件并加载到内存中。

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

3.在堆内存中开辟空间，分配内存地址。

4.在堆内存中建立对象的特有属性，并进行默认初始化(字符串为null，int为0)。

5.对属性进行显示初始化。(Stringname = “htc”;)

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

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

8.将内存地址赋给栈内存中的变量。

对象调用成员过程

设计模式：解决某一类问题最行之有效的方法。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 day06 
{
	public static void main(String[] args)
	{
		Single ss = Single.getInstance();
	}
}

保证了对象的唯一性。

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 day06 
{
	public static void main(String[] args)
	{
		Single s1 = Single.getInstance();
		Single s2 = Single.getInstance();
		s1.setNum(23);
		System.out.println(s2.getNum());
	}
}

输出 23

s1,s2都指向同一个对象

对于事物该怎么描述，还怎么描述。当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上去即可。

class Student
{
	private int age;

	//1,2,3步开始
	private static Student s = new Student();
	private Student(){}
	public static Student getInstance()
	{
		return s;
	}
	//1,2,3步结束

	public void setAge(int age)
	{
		this.age  = age;
	}
	public int getAge(int age)
    {
		return age;
	}

}

main函数中

Student s1 = Student.getInstance();

Student s2 = Student.getInstance();

另一种方式：（另一种写法）

/*这个是先初始化对象
称为：饿汉式
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)//可能出安全问题,可以写成static synchronized Single getInstance(),但程序效率低了
		{
			s = new Single();
		}
		/*最佳解决方案
		if(s == null)
		{
			synchronized(Single.class)
			{
				if(s == null)
					s = new Single();
			}
		}
		*/

		return s;
	}
}

class day06 
{
	public static void main(String[] args)
	{
		Single s1 = Single.getInstance();
	}
}

记住原则：定义单例，建议使用饿汉式。

同学少年

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[Java视频笔记]day06

静态：static用法：是一个修饰符用于修饰成员（成员变量，成员函数）,修饰的内容被对象所共享。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。写法格式：类名.静态成员class Person{ String name; static String country = "CN"; public void show() { System.
复制链接

扫一扫