入门Java编程的知识点—＞静态方法（day11）
- 重点掌握final关键字特点？final的语法使用?
- 重点掌握静态变量是什么？静态变量的语法与使用?了解方法区内存图执行过程?
- 重点掌握静态方法是什么？静态方法的语法特点与使用?
- 重点掌握常量语法如何定义与使用?
final(最终)
final可以用于修饰类,方法,属性。
-
修饰属性：用final修饰的属性,不可二次修改,且修饰成员变量,需要初始化赋值！
-
修饰方法：用final修饰的方法,不能够被子类重写！(存在继承的父级代码中！)
-
修饰类： 用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 (静态)
静态变量适用性：当有一份数据,需要被多个对象使用,我们可以做成静态变量。
成员变量分为两种：
- 实例变量(成员变量)：属于对象的！(有多少个对象就有多少份数据),在堆中存储。
- 通过对象打点来进行访问。
- 静态变量: 属于类的(只有一份)！,在方法区中存储。
- 通过类名打点进行访问。
- 静态变量就是用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修饰的方法称之为静态方法。
-
静态方法属于类的，访问通过类名打点进行访问。
-
存储在方法区中。
-
静态的方法 没有 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.数据的稳定性。
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;非同包子类 不可访问 私有权限
}
}