概述
static关键字
一、static修饰成员变量
如果一个成员变量使用了static关键字，name这个对象不再属于对象自己，而是属于所在的类，多个对象共享一份数据
package cn.itcast.day08.demo03;
public class Demo01StaticField {
public static void main(String[] args) {
Student two = new Student("黄蓉,",16);
two.room = "101教室,";
System.out.println("姓名：" + two.getName()
+ "年龄：" + two.getAge() + ",教室是：" + two.room
+ "学号" + two.getId());
Student one = new Student("郭靖,", 19);
System.out.println("姓名：" + one.getName()
+ "年龄：" + one.getAge() + ",教室是：" + one.room
+ "学号" + one.getId());
}
}
package cn.itcast.day08.demo03;
public class MyClass {
int num; //成员变量。
static int numClass; //静态变量
//成员方法(非静态)
public void method(){
System.out.println("这是一个成员方法。");
//下列语句说明成员方法可以访问成员变量
System.out.println(num);//能调用
//下列语句说明成员方法可以访问静态变量
System.out.println(numClass);//能调用
}
//静态方法
public static void methodStatic(){
System.out.println("这是一个静态方法。");
//下列语句说明静态方法可以访问静态变量
System.out.println(numClass);
//静态不能访问非静态
// System.out.println(num);
}
}
二、static修饰成员方法
* 一旦使用了static修饰成员方法，name这就成功为了静态方法。静态方法不属于对象，而是属于类的。
* 如果没有static关键字，name必须首先创建对象，然后通过对象才能使用它。
* 如果有了static关键字，name不需要创建对象，直接就能通过类名称来使用它。
无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称来调用。
静态变量：类名称.静态变量
静态方法：类名称.静态方法()
* 注意事项：
1. 静态方法只能直接访问静态成员变量，不能直接访问非静态。
原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容
“先人不知道后人，但后人知道先人。”
2. 静态方法当中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是当前的对象。
package cn.itcast.day08.demo03;
public class Demo02StaticMethod {
public static void main(String[] args) {
MyClass obj = new MyClass();//首先创建对象
//然后才能使用没有static关键字的内容
obj.method(); //对象调用普通的成员方法
//对于静态方法来说，可以使用对象名进行调用，也可以直接通过类名称来调用
obj.methodStatic(); //正确，不推荐， 原因：容易误以为这是一个普通的成员方法
//上面这种写法在编译之后也会被javac翻译成为 “类名称.静态方法名”
MyClass.methodStatic(); //正确，推荐
//对于本类当中的静态方法，也可以省略类名称
myMethod();
Demo02StaticMethod.myMethod(); //完全等效
}
public static void myMethod(){
System.out.println("自己的方法！");
}
}
package cn.itcast.day08.demo03;
public class Demo03StaticStudent {
public static void main(String[] args) {
//首先设置一下教室，这是静态的东西，应该通过类名称进行调用
Student.room = "101教室";
Student one = new Student("郭靖",20);
System.out.println("one的姓名：" + one.getName());
System.out.println("one的年龄：" + one.getAge());
System.out.println("one的教室：" + Student.room); //调用静态成员变量：类名称.变量名
System.out.println("================");
Student two = new Student("黄蓉", 16);
System.out.println("two的姓名：" + two.getName());
System.out.println("two的年龄：" + two.getAge());
System.out.println("two的教室：" + Student.room); //调用静态成员变量：类名称.变量名
}
}
static修饰的静态成员变量与类和对象的关系
根据类名称访问静态成员变量的时候，全程和对象就没有关系，只和类有关系。
package cn.itcast.day08.demo03;
/*
静态代码块的格式是：
public class 类名称{
static {
//静态代码块的内容
}
}
特点：当第一次用到本类时，静态代码块执行唯一的一次。
*/
public class Person {
static{
System.out.println("静态代码块执行！");
}
public Person(){
System.out.println("构造方法执行！");
}
}
三、static静态代码块
* 静态代码块的格式是：
public class 类名称{
static {
//静态代码块的内容
}
}
* 特点：
- 当第一次用到本类时，静态代码块执行唯一的一次。
- 静态内容总是优先于非静态，所以静态代码块 比 构造方法先执行。
* 静态代码块的典型用途：
- 用来一次性地对静态成员变量进行赋值。
package cn.itcast.day08.demo03;
public class Demo04Static {
public static void main(String[] args) {
Person one = new Person();
Person two = new Person();
}
}
final关键字
final关键字代表最终、不可改变的。
* 常见四种用法：
1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 还可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量
一、final关键字用来修饰一个类
* 当final关键字用来修饰一个类的时候，格式：
public final class 类名称{
...
}
* 含义：当前这个类有父类，【但不能有任何的子类】。
* 注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没子类）
package cn.itcast.day11.demo01;
public final class MyClass /*extends Object*/ {
public void method(){
System.out.println("方法执行！");
}
}
package cn.itcast.day11.demo01;
//不能使用一个final类作为父类
public class MySubClass /*extends MyClass*/ {
}
二、final关键字用来修饰一个方法
* 当final关键字用来修饰一个方法的时候，这个方法就是最终方法（也就是不能被覆盖重写）。
* 格式：
修饰符 final 返回值类型 方法名称（参数列表）{
//方法体
}
* 注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾
（抽象是没有方法体的，抽象方法所在的类必须是抽象类）
package cn.itcast.day11.demo01;
public abstract class Fu {
public final void method(){
System.out.println("父类方法执行");
}
public abstract void methodAbs();
}
package cn.itcast.day11.demo01;
public class Zi extends Fu {
/*
@Override
public void method() {
System.out.println("子类覆盖重写父类的方法！");
} //错误写法！不能覆盖重写final的方法
*/
@Override
public void methodAbs() {
}
}
三、final关键字用来修饰一个局部变量
一旦使用final来修饰局部变量，那么这个变量就不能进行更改。
一次赋值，终生不变。
* 对于基本类型来说，不可变说的是变量当中的数据不可改变。
* 对于引用类型来说，不可变说的是变量当中的地址值不可改变，但地址中的内容也可以改变。
package cn.itcast.day11.demo01;
public class Student {
private String name;
public Student(){
}
public Student(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package cn.itcast.day11.demo01;
public class Demo01Final {
public static void main(String[] args) {
int num1 = 10;
System.out.println(num1); //10
num1 = 20;
System.out.println(num1); //20
//一旦使用final来修饰局部变量，n那么这个变量就不能进行更改
//一次赋值，终生不变
final int num2 = 200;
System.out.println(num2); //200
// num2 = 250; //错误写法
// num2 = 200; //错误写法
//正确写法！只要保证一次赋值即可
final int num3;
num3 = 30;
//对于基本类型来说，不可变说的是变量当中的数据不可改变
//对于引用类型来说，不可变说的是变量当中的地址值不可改变，但地址中的内容也可以改变
Student stu1 = new Student("赵丽颖");
System.out.println(stu1); //输出 stu1的地址值
System.out.println(stu1.getName()); //赵丽颖
stu1 = new Student("霍建华");
System.out.println(stu1); //输出 stu1的地址值，此时地址值发生了改变
System.out.println(stu1.getName()); //霍建华
final Student stu2 = new Student("高圆圆");
//下列赋值为错误写法！final的引用类型变量，其中的地址不可改变
// stu2 = new Student("赵又廷");
// 对于引用类型来说，不可变说的是变量当中的地址值不可改变，但地址中的内容也可以改变
System.out.println("stu2.getName()"); //高圆圆
stu2.setName("高圆圆圆圆圆圆");
System.out.println("stu2.getName()"); //高圆圆圆圆圆圆圆，内容可变，但地址值没有发生改变
}
}
* 对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
1. 由于成员变量具有默认值，一旦默认值被放了进去，也算是赋值。所以用了final之后必须手动赋值，不会再给默认值了
2. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
3. 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
package cn.itcast.day11.demo01;
public class Person {
private final String name/* = "鹿晗"*/;
public Person() {
name = "关晓彤";
}
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
/*
public void setName(String name) {
this.name = name;
}
*/
}
最后
以上就是鳗鱼篮球为你收集整理的static关键字、final关键字static关键字final关键字的全部内容，希望文章能够帮你解决static关键字、final关键字static关键字final关键字所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复