尚硅谷_Java零基础教程（面向对象下）--学习笔记（十四)

Static关键字

package com.atguigu.java;
/*
 * static关键字的使用
 * 
 * 1、static：静态的
 * 2、static可以用来修饰：属性、方法、代码块、内部类
 * 
 * 3、使用static来修饰属性：静态变量（或类变量）
 * 		（1）属性，按属否使用static修饰，又分为：静态属性vs非静态属性
 * 		实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类的实例变量。当修改一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
 * 		静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量，当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过的。
 * 		（2）static修饰属性的其他说明：静态变量随着类的加载而加载、静态变量的加载要早于对象的创建、可以通过"类.静态变量"的方式进行调用、由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
 * 		（3）类变量	实例变量
 * 		类	 yes	no
 * 		对象  yes	yes
 * 		（4）静态属性举例：System.out;Math.PI
 * 方法区：类的加载信息、静态域、常量池。 
 * 
 * 4、使用static来修饰方法：静态方法
 * 	（1）随着类的加载而加载，可以通过"类.静态方法"的方式调用。
 * 	（2）静态方法		实例方法
 * 	 类	 yes		no
 *   对象 yes		yes
 *  （3）静态方法中，只能调用静态的方法或属性。
 *  	非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性。
 *
 *5.static注意点：
 *	在静态的方法内，不能使用this关键字、super关键字。
 *
 *6.开发中，如何确定一个属性是否要声明为static的？
 *	（1）属性可以被多个对象所共享的，不会随着对象的不同而不同的。
 *
 *7.开发中，如何确定一个方法是否要声明为static的？
 *	（1）操作静态属性的方法，通常都设置为静态的。
 *	（2）工具类中的方法，习惯上声明为静态的，比如：Math,Arrays,Collections
 */
public class StaticTest {
	public static void main(String[] args) {
		Chinese c1 = new Chinese();
		c1.name = "姚明";
		c1.age = 40;
		
		Chinese c2 = new Chinese();
		c2.name = "马龙";
		c2.age = 35;
		
		c1.nation = "CHN";
		
		System.out.println(c2.nation);
	}
}
// 中国人
class Chinese{
	String name;
	int age;
	static String nation;
}

package com.atguigu.exer1;

public class Account {
    private int id;
    private String pwd = "000000";
    private double balance;

    private static double interestRate;
    private static double minMoney = 1.0;
    private static int init = 1001; // 用于自动生成id

    public String getPwd(){
        return this.pwd;
    }

    public void setPwd(String pwd){
        this.pwd = pwd;
    }

    public double getBalance(){
        return this.balance;
    }

    public static double getInterestRate(){
        return Account.interestRate;
    }

    public static void setInterestRate(double interestRate){
        Account.interestRate = interestRate;
    }

    public static double getMinMoney(){
        return Account.minMoney;
    }

    public static void setMinMoney(double minMoney){
        Account.minMoney = minMoney;
    }

    public Account(){
        id = init++;
    }

    public Account(String pwd, double balance){
        id = init++;
        this.pwd = pwd;
        this.balance = balance;
    }

    public String toString(){
        return "" + id + pwd + balance;
    }
}

package com.atguigu.exer1;

public class AccountTest {
    public static void main(String[] args){
        Account acct1 = new Account();
        Account acct2 = new Account("123456", 1000.0);

        System.out.println(acct1);
        System.out.println(acct2);
    }
}

package com.atguigu.java;
/*
    一、单例设计模式。
    1、定义：所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例。
    2、如何实现？
	
	3、区分俄汉式和懒汉式
		俄汉式：坏处：对象加载时间过程。线程安全。
		懒汉式：好处：延迟对象的创建。目前写法线程不安全。
 */
public class SingletonTest {
    public static void main(String[] args){
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();

        System.out.println(bank1 == bank2);
    }
}

//饿汉式
class Bank{
    //1.私有化类的构造器
    private Bank(){

    }
    //2.内部创建类的对象
    //4.要求此属性也必须声明为静态的
    private static Bank instance = new Bank();

    //3.提供公共的静态方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

package com.atguigu.java;
/*
    单例模式的懒汉式实现
 */
public class SingletonTest2 {
    public static void main(String[] args){
        Order order1 = Order.getInstance();
        Order order2 = Order.getInstance();
        System.out.println(order1 == order2);
    }
}

class Order{
    //1.私有化类的构造器
    private Order(){

    }
    //2.声明当前类对象，没有初始化。
    //4.此对象也必须声明为static的。
    private static Order instance = null;

    //3.声明public、static的返回当前类对象的方法
    public static Order getInstance(){
        if(instance == null){
            instance = new Order();
        }
        return instance;
    }
}

package com.atguigu.java;
/*
 * final:最终的
 * 1.final可以用来修饰的结构：类、方法、变量；
 * 
 * 2.final 用来修饰一个类：此类不能被其他类继承
 * 		比如，String  
 * 
 * 3.final 用来修饰方法：表明此方法不可以被重写。
 * 		比如，Object类的getClass：获取当前对象所属的类。
 * 
 * 4.final 用来修饰变量：此时的“变量”就称为一个常量。
 * 	（1）final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中赋值、构造器中初始化
 *	（2）final修饰局部变量
 *		尤其是使用final来修饰形参时，表明此形参是一个常量，当我们调用方法时，给常量形参赋一个值。一旦赋值以后，就只能在方法体内使用此形参，不能赋值。
 *
 * static final 用来修饰属性，全局常量。
 */
public class FinalTest {
	public static void main(String[] args) {
		int num = 10;
		num = num + 5;
		
	}
}

final class FinalA{
	 
}