入门Java编程的知识点—＞静态方法（day11）

• 重点掌握final关键字特点？final的语法使用?
• 重点掌握静态变量是什么？静态变量的语法与使用?了解方法区内存图执行过程?
• 重点掌握静态方法是什么？静态方法的语法特点与使用?
• 重点掌握常量语法如何定义与使用?

final(最终)

final可以用于修饰类,方法,属性。

1. 修饰属性：用final修饰的属性,不可二次修改,且修饰成员变量,需要初始化赋值！

2. 修饰方法：用final修饰的方法,不能够被子类重写！(存在继承的父级代码中！)

3. 修饰类： 用final修饰的类,该类不能够被继承！

package oo.day03;

/**
 * final的使用演示类：
 */
public class FinalDemo {
    private final int a = 100;//final修饰的成员变量 需初始化赋值
    void show(){
//        a = 200; final修饰的变量不可二次修改！
    }
}
final class  Aoo{ //final修饰的类
    final void show(){ // final修饰的方法
    }
}
class  Boo /*extends Aoo*/ {//不能够继承final修饰的类。
//    @Override
//   public void show() { 不能重写final修饰的方法！
//
//    }
}

思考

每个学生手里拿的杯子,都是当前对象的,属于个人的。

饮水机只有一台不属于对象！但是可以被对象共享！----生活中静态的概念

1. static (静态)

静态变量适用性：当有一份数据,需要被多个对象使用,我们可以做成静态变量。

成员变量分为两种：

1. 实例变量(成员变量)：属于对象的！(有多少个对象就有多少份数据),在堆中存储。

• 通过对象打点来进行访问。

1. 静态变量: 属于类的(只有一份)！,在方法区中存储。

• 通过类名打点进行访问。

1. 静态变量就是用static修饰的变量,称之为静态变量。

一个类对应的.class字节码,会在当前类被首次使用时,加载到方法区中，且只会被加载一次。

JVM分配空间：栈区,堆区,方法区。 1.栈区放局部变量 2.堆区放对象 3.方法区：用来加载.class字节码文件(类中的方法(构造方法,普通方法,静态方法)/静态变量)

    
package oo.day03;
/**
 * 静态变量的使用演示类：
 */
public class StaticDemo {
    public static void main(String[] args) {
        Coo c1 = new Coo();//创建一个Coo对象
        c1.show(); // a 1  b 1
        Coo c2 = new Coo();//创建一个Coo对象
        c2.show(); // a 1  b 2
        Coo c3 = new Coo();//创建一个Coo对象
        c3.show(); // a 1  b 3
        System.out.println( Coo.b );//访问静态资源 通过类名的形式打点调用
        System.out.println( c3.a); //访问实例资源  通过对象的形式打点调用
    }
}
class Coo {
    public int a;// 实例变量 -----> 属于对象的----->      杯子
    public static int b;//静态变量 -----> 属于类的 ---->  饮水机
    Coo(){
        a++;
        b++;
    }
    void show() {
        System.out.println("实例变量a的数据为:" + a +"静态变量b的数据为" + b);
    }
}

2. 方法区内存图示:

3. 静态方法:

用static修饰的方法称之为静态方法。

1. 静态方法属于类的，访问通过类名打点进行访问。

2. 存储在方法区中。

3. 静态的方法 没有 this传递 (不能有this 关键字)，所以静态方法无法访问实例成员(普通方法,实例成员变量)

适用性：静态方法一般只会存在于工具类中,对于外部调用非常方便,无需创建对象即可使用。

package oo.day03;

/**
 * 静态变量的使用演示类：
 * 静态方法的使用演示类：
 */
public class StaticDemo {
    public static void main(String[] args) {
//        System.out.println( Coo.b );//访问静态资源 通过类名的形式打点调用
//        System.out.println( c3.a); //访问实例资源  通过对象的形式打点调用
        Coo.show2();//访问静态方法，通过类名点的形式
        //随机数的功能
        Math.random();
    }
}
class Coo {
    public int a;// 实例变量 -----> 属于对象的----->      杯子
    public static int b;//静态变量 -----> 属于类的 ---->  饮水机

    public void show() { //普通方法 (自定义方法)
        this.a = 1; //访问实例变量  ----->隐式 this写法
        Coo.b = 2;//访问静态变量        ----->隐式 类名打点写法
    }
    public static void show2() { //静态方法 ---->现象是没有隐式this传递
//        this.a = 1; // 没有隐式 this传递
//         show();  无法访问 实例成员变量 /普通方法
        b = 2;//静态方法可以访问静态成员(静态变量/静态方法)。
    }
}

常量：

用static final 修饰的变量则是常量。常量结合了static 和final的特性。

特性：可以通过类名方式访问,不能二次修改,声明时需要初始化。

1. 常量命名要求纯大写。多个单词之间用下划线隔开。

2. 常量的适用性：当一份数据,确定下来以后,几乎不会改变,那么也不能被修改,我们可以声明为常量

1.方便使用 2.数据的稳定性。

package oo.day03;

/**
 * 常量的使用演示类：
 */

public class StaticFinalDemo {
    public static void main(String[] args) {
        //1.先将Eoo.class字节码文件加载到方法区中
        //2.打印输出当前 a的值
        System.out.println( Eoo.a); //访问静态变量
//        Eoo e = new Eoo();
//        e.b = 1000; 不可二次修改  可以直接用。
        
        //在编译期间,本质上就将C这个常量中的数值转换为具体的数据！
//        System.out.println(200);
        System.out.println(Eoo.C); // 访问常量
    }
}

class Eoo {
    public static int a = 2000;//静态变量
    public final  int b = 100;//用final修饰的变量  不可二次修改
    public static final int C = 200; //常量     属于类的,通过类名来访问。

    static {
        System.out.println("Eoo这个类的静态代码块执行了....");
    }

}

1. 扩充(时间允许情况下的内容):

① package(包)

作用：避免类名冲突,同包中不允许存在同名文件。

包名：纯小写,工作包规范：域名反写.项目名称.模块名称.类名

类的全包名：包名.类名

package day01;
class HelloWorld{ //类的全包名： day01.HelloWorld
}

② import(导入)

适用性：当前类需要用到某些功能时,而这些功能不再当前类的同包中,则需要通过import导入要使用的功能类的全包名即可。

快捷导入功能的全包名：alt + Enter + Enter

• 如果使用的类在当前类的同包下,直接访问即可！

2. 访问修饰符

控制代码的可见范围,目的保护程序的合法性,安全性,健壮性。

迪米特原则："不要和陌生人说话",类的成员能私有尽量私有!

属性的封装: 属性私有化,方法公开化. 对外可以获取的权限,可以设置的权限 具体看需要

public : 公开, 当前类/ 同包类 / 子类 /非同包类

protected:保护 , 当前类/同包类/子类

默认的(不写) : 当前类/同包类

private: 私有 当前类

class Card{ //卡类
    private int CardPwd;//卡密码
    private int balance;//账户余额 
    
    public void checkCardPwd(int pwd){
        if(pwd == CardPwd){
            System.out.println("密码正确,授权成功..可以进入操作业务"); 	
        }else{
            System.out.println("密码输入错误还剩..."); 	
        }
    }
    
    public void setBalance(int money){
        if(money > 0){
            balance += money;
        }
    }
   
    public int getBalance(){ //可以供外部获取该余额的方法
        return balance;
    }  
    
}

① 当前类/同包类测试:

package oo.test01;

/**
 * 访问修饰符测试:
 * public   : 当前类/同包类/子类/非同包类
 * protected: 当前类/同包类/子类
 * 默认的    : 当前类/同包类
 * private  : 当前类
 */
public class Aoo {
    public int a; //公开
    protected int b;//保护
    int c;//默认
    private int d;//私有的
    void test() {
        a = 1;//当前类可见
        b = 2;//当前类可见
        c = 3;//当前类可见
        d = 4;//当前类可见
    }
}
class Boo{ //同包类
    void test(){
        Aoo aoo = new Aoo();
        aoo.a = 1;//同包类可见
        aoo.b = 2;//同包类可见
        aoo.c = 3;//同包类可见
//        aoo.d = 4;//私有成员同包类不可见
    }
}

② test02

package oo.test02;

import oo.test01.Aoo;
public class Coo {
    void test(){
        Aoo aoo = new Aoo();
        aoo.a = 1; //公开的非同包可访问
//        aoo.b = 2; 保护的 非同包类不可访问
//        aoo.c = 3; 默认的 非同包类不可访问
//        aoo.d = 4; 私有的 非同包类不可访问
    }
}

class Doo extends Aoo{
    void test(){
        a = 1;//非同包子类 可以访问 公开权限
        b = 2;//非同包子类 可以访问 保护权限
//        c = 3;非同包子类 不可访问 默认权限
//        d = 4;非同包子类 不可访问 私有权限
    }
}