day11

于 2020-02-29 17:41:02 发布
阅读量160 收藏
点赞数
分类专栏： javase 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44132400/article/details/104578238
版权
static关键字

有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份。

在这里插入图片描述

简单使用：

package cap14;

public class StaticTest {
	public static void main(String[] args) {
		System.out.println(Circle.getTotal());//0
		Circle c1 = new Circle(2.0);
		Circle c2 = new Circle(3.0);
		System.out.println(Circle.getTotal());//2
	}
}
class Circle{
	private double radius;
	private static int total = 0;
	public Circle(double radius) {
		this.radius = radius;
		total++;
	}
	public static int getTotal() {
		return total;
	}
}

static关键字的使用

 /*
 * 1.static:静态的
 * 2.static可以用来修饰：属性、方法、代码块、内部类
 * 
 * 3.使用static修饰属性：静态变量（或类变量）
 * 		3.1 属性，按是否使用static修饰，又分为：静态属性  vs 非静态属性(实例变量)
 * 		   实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的
 *              非静态属性时，不会导致其他对象中同样的属性值的修改。
 *       静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致
 *              其他对象调用此静态变量时，是修改过了的。
 * 		3.2 static修饰属性的其他说明：
 * 			① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
 *          ② 静态变量的加载要早于对象的创建。
 *          ③ 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
 *          
 *          ④		类变量	实例变量
 *          类		yes		no
 *          对象		yes		yes
 *          
 *      3.3 静态属性举例：System.out; Math.PI;
 * 
 * 4.使用static修饰方法：静态方法
 * 		① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
 * 		②			静态方法	非静态方法
 *          类		yes		no
 *          对象		yes		yes
 * 		③ 静态方法中，只能调用静态的方法或属性
 *        非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
 * 
 * 5. static注意点：
 *    5.1 在静态的方法内，不能使用this关键字、super关键字
 *    5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解。
 *    
 * 6. 开发中，如何确定一个属性是否要声明为static的？
 * 		> 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
 * 		> 类中的常量也常常声明为static
 * 
 *    开发中，如何确定一个方法是否要声明为static的？
 *    	> 操作静态属性的方法，通常设置为static的
 *      > 工具类中的方法，习惯上声明为static的。 比如：Math、Arrays、Collections
 */

内存解析

在这里插入图片描述

练习：

package cap14;
/**
 * 编写一个类实现银行账户的概念，包含的属性有“帐号”、“密码”、“存款余额”、“利率”、“最小余额”，定义封装这些属性的方法。账号要自动生成。编写主类，
 * 使用银行账户类，输入、输出3个储户的上述信息。
 * 考虑：哪些属性可以设计成static属性
 * @author xiao-liu
 *
 */
public class StaticExe {
	public static void main(String[] args) {
		Bank b1 = new Bank(1000);
		Bank b2 = new Bank(2000,"wenfoew");
		Bank b3 = new Bank(3000);
		System.out.println(b1);
		System.out.println(b2);
		System.out.println(b3);
	}
}
class Bank{
	private int id;
	private String password = "000000";
	private double deposits;//存款余额
	private double interestRate = 0.0101;//利率
	private double  minimumBalance = 1000;//最小余额
	private static int total = 1001;
	public Bank(double deposits) {
		this.deposits = deposits;
		this.id = total++;
	}
	public Bank(double deposits,String password) {
		this(deposits);
		this.password = password;
	}
	@Override
	public String toString() {
		return "Bank [id=" + id + ", password=" + password + ", deposits=" + deposits + ", interestRate=" + interestRate
				+ ", minimumBalance=" + minimumBalance + "]";
	}
	public void setPassword(String password) {
		this.password = password;
	}
}
单例设计模式（Singleton）

概念：所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构 造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

实现方式：

实现方式一：

饿汉式：

public class SingletonTest {
	public static void main(String[] args) {
		Bank bank1 = Bank.getBank();
		Bank bank2 = Bank.getBank();
		System.out.println(bank1 == bank2);
	}
}
class Bank{
	private static Bank bank = new Bank();
	private Bank(){
		
	}
	public static Bank getBank() {
		return bank;
	}
}

懒汉式：

public class SingletonTest {
	public static void main(String[] args) {
		Bank bank1 = Bank.getBank();
		Bank bank2 = Bank.getBank();
		System.out.println(bank1 == bank2);
	}
}
class Bank{
	private static Bank bank = null;
	private Bank(){
		
	}
	public static Bank getBank() {
		if(bank == null) {
			bank = new Bank();
		}
		return bank;
	}
}

单例设计模式：
 * 1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
 * 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其   	他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决
 * 2. 如何实现？
 * 	 饿汉式  vs 懒汉式
 * 
 * 3. 区分饿汉式 和 懒汉式
 *   饿汉式：	
 *   	坏处：对象加载时间过长。
 *   	好处：饿汉式是线程安全的
 *   
 *   懒汉式：好处：延迟对象的创建。
 * 		  目前的写法坏处：线程不安全。--->到多线程内容时，再修改
 *

应用场景

  1. 网站的计数器，一般也是单例模式实现，否则难以同步。
  2. 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
  3. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
  4. 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取
  5. Application 也是单例的典型应用
main方法

由于Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，又因为Java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数

又因为main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在之前的例子中多次碰到

main()方法的使用说明：

  1. main()方法作为程序的入口
  2. main()方法也是一个普通的静态方法
  3. main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）
public class MainTest {
	public static void main(String[] args) {
		for(int i = 0;i < args.length;i++) {
			System.out.println(args[i]);
		}
	}
}
/*
	22
	33
	44
	dwqf
*/

参数传递：

在这里插入图片描述

代码块
类的成员之四：代码块（或初始化块）
 * 
 * 1. 代码块的作用：用来初始化类、对象
 * 2. 代码块如果有修饰的话，只能使用static.
 * 3. 分类：静态代码块  vs 非静态代码块
 * 
 * 4. 静态代码块
 * 	   >内部可以有输出语句
 * 	   >随着类的加载而执行,而且只执行一次
 * 	   >作用：初始化类的信息
 * 	   >如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
 * 	   >静态代码块的执行要优先于非静态代码块的执行
 * 	   >静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
 * 
 * 5. 非静态代码块
 * 		>内部可以有输出语句
 * 		>随着对象的创建而执行
 * 		>每创建一个对象，就执行一次非静态代码块
 * 		>作用：可以在创建对象时，对对象的属性等进行初始化
 * 		>如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
 * 		>非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

public class Block {
	public static void main(String[] args) {
		/*
		 * 111111111
		 * 1212
		 * 2222222
		 * 2222222
		 * 2222222
		 */
		System.out.println(Person.getS());
		new Person();
		new Person();
		new Person();
	}
}
class Person{
	private static String s = "1212";
	static {
		System.out.println("111111111");
	}
	{
		System.out.println("2222222");
	}
	public static String getS() {
		return s;
	}
}

对属性可以赋值的位置：

①默认初始化

②显式初始化/⑤在代码块中赋值

③构造器中初始化

④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值

执行的先后顺序：① - ② / ⑤ - ③ - ④

package cap14;

public class BlockTest {
	public static void main(String[] args) {
		Person1 p = new Person1();//1002
		System.out.println(p.id);
		Person2 p2 = new Person2();
		System.out.println(p2.id);//1001
	}
}
class Person1{
	
	int id = 1001;
	{
		id = 1002;
	}
}
class Person2{
	{
		id = 1002;
	}
	int id = 1001;	
}
final关键字
final:最终的
 * 
 * 1. final可以用来修饰的结构：类、方法、变量
 * 
 * 2. final 用来修饰一个类:此类不能被其他类所继承。
 *          比如：String类、System类、StringBuffer类
 * 
 * 3. final 用来修饰方法：表明此方法不可以被重写
 * 			比如：Object类中getClass();
 * 
 * 4. final 用来修饰变量：此时的"变量"就称为是一个常量
 * 	    4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
 * 		4.2 final修饰局部变量：
 *           尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值
 *           以后，就只能在方法体内使用此形参，但不能进行重新赋值。
 *           
 *  static final 用来修饰属性：全局常量

class Animal{
	final String name;
	final String name1;
	{
		name = "lisi";
	}
	public Animal() {
		name1 = "dq";
	}
}

fianl修饰的关键字不会进行默认初始化，在对象创建完成之前就已经确定好了，所以在对象.方法中是无法进行赋值的，因为对象.方法操作对象已经被创建出来了。时机不同

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值