本文详细介绍了Java编程中的final、static、abstract特征修饰符以及接口的概念和用法。final用于声明不可变的变量、方法和类；static用于声明静态成员，包括静态变量、静态方法和静态初始化块，它们属于类而不是对象；abstract用于声明抽象类和抽象方法，抽象类不能实例化，但可以被继承。此外，文章还讨论了接口的特性和使用方式，接口中的成员只能是常量和抽象方法，实现接口的类必须实现所有接口方法。
目录
Java特征修饰符
一、Java特征符概述
Java特征修饰符有以下7种
| 修饰符 | 说明 |
| final | 最终的，不可改变的 |
| static | 静态的 |
| abstract | 抽象的 |
| native | 本地的，看到native就是java代码的尽头 |
| transient | 瞬时的，短暂的——》序列化 |
| synchronized | 同步的，线程相关的知识 |
| volatile | 保护属性或方法的线程关系 |
下面主要介绍final、static、abstract特征修饰符
二、final特征修饰符
final 最终的、不可更改的
1.修饰什么？
①修饰变量：
写法一：
final int a=1;
//a=5; //错误写话，final修饰之后，变量的值不能再修改
写法二：
final int b;
b=10;
//b=13;//错误写法，只能赋值一次
如果一开始没有赋值则一次赋值的机会
*注意：final修饰变量需要注意变量类型是基本类型还是引用类型
如果是基本类型，则变量的值不可以修改
如果是引用类型，则变量的地址引用不可以改变
②修饰属性：
属性没有赋值，有默认值存在，用final修饰必须赋值
③方法:
final修饰后，方法是最终的方法，不可以更改
在继承中，子类继承父类的方法，并且可以重写父类的方法
如果父类中方法被final修饰，则子类不能修改
④修饰类（public final class 类名）
修饰类，则类不能修改，最后的
也就是类被final修饰，不能被继承，即没有子类
（ 大家可以想象一下，就是被final修饰即太监类，没有后代）
如：Math、Scanner、Integer,String
2.代码展示
Test类
package final特征符;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
final String Name="siri";
//第一种写法
final int a=1;
//a=5; //错误写话，final修饰之后，变量的值不能再修改
//第二种写话
final int b;
b=10;
//b=13;//错误写法，只能赋值一次
final int[] x=new int [] {1,2,3};
//x=new int[5];//错误写法，final修饰X不能再进行引用
//但是在里面可以赋值
x[0]=10;
//测试final修饰的方法
Person p=new Person();
p.eat();
}
}Animal类
package final特征符;
public class Animal {
public final void eat() {
System.out.println("父类的方法");
}
}
Person类
package final特征符;
public class Person extends Animal{
//子类想重写父类的方法，发现报错，所以final修饰的父类方法子类不能重写
public void eat() {
System.out.println("子类重写父类");
}
}
三、static 特性修饰符
1.修饰什么？
①修饰属性
public static age=14；
②修饰方法
public static void eat（）{}
非静态成员可以访问静态成员
静态成员可以访问静态成员
静态成员不可以访问非静态成员
静态元素不可以使用this和super关键字
③修饰块
如果在执行类时，希望先执行类的初始化对象，可以使用static定义的一个静态区域，这段代码执行时，首先执行static块中的程序，并且只执行一次。
static {
System.out.println("我是静态块");
}
④修饰内部类
静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。
想了解更多内部类可以点击下方，直接跳转
2.修饰之后特点
①static修饰在静态元素区，每一个类有一个区域
②静态元素一个类只有一份，一个类的全部对象共享一个
③静态元素在类加载已经初始化啦
④通过类名直接访问，或者类名.的方法访问静态成员的静态方法
类名.静态成员
类名.静态方法
⑤在内存管理
栈内存创建用完就回收
堆内存通过GC（垃圾回收器）回收
静态元素区GC不能管理
⑥普通方法和静态方法分别互相访问成员变量
对于普通方法
非静态方法可以访问静态成员
非静态方法可以访问非静态成员
对于静态方法
静态方法可以访问静态成员
静态方法不可以访问非静态成员
⑦非静态方法和静态方法互相访问
静态方法不可以调用非静态方法
非静态方法可以调用静态方法
*注意：静态方法中不可以使用this和super
方法体内不能定义static的局部变量
3.代码展示
package static特征符;
public class Person {
public String name;
public static int age;//被static修饰，属性发现变斜
//静态块
static {
System.out.println("我是静态块");
}
//构造方法
public Person() {
System.out.println("person的构造方法");
}
//普通方法
public void eat(){
//普通方法可以访问静态的成员,Person.age
System.out.println("我是普通方法"+Person.age);
//普通方法可以访问非静态的成员
System.out.println(name);
//普通方法可以访问静态方法
eatStatic();
}
//静态方法
public static Person eatStatic() {
//静态方法可以访问静态的成员,Person.age
System.out.println("我是静态方法"+Person.age);
//静态方法不可以访问非静态成员
//System.out.println(name);
//静态方法不能访问普通方法
//eat();
//不能使用this
//return this;
}
public static void main(String[] args) {
//创建person类的p1对象
Person p1=new Person();
p1.name="小白";
p1.age=18;
//创建person类的p2对象
Person p2=new Person();
p2.name="小黑";
p2.age=16;
// try {
// //类的全名称，反射机制加载类
// Class.forName("static特征符.Person");
// }catch(Exception e) {
//
// }
//输出这两个对象
/*
* 运行结果：
* 小白今年16
* 小黑今年16
* 运行发现一开始小白age为18，小黑age为16，但是结果都是16
* 原因：static不属于栈也不是堆，而是在静态元素区，只有一份。
*/
System.out.println(p1.name+"今年"+p2.age);
System.out.println(p2.name+"今年"+p2.age);
}
}四、abstract特性修饰符
1.修饰什么？
①修饰类
用abstract修饰类，
②修饰方法
用abstract修饰的抽象方法没有方法体，这个方法本身没有任何意义，除非被重写，然后含有的抽象方法的抽象类必须被继承，然后让子类来重写方法。
*注意：抽象方法的类必须是抽象类，抽象类可以没有抽象方法
2.修饰后的特点
抽象类含有构造方法，但是我们不能只能创建抽象类的对象
我们可以让子类去继承抽象类，用子类来创建对象来调用抽象类中的方法或者重写抽象方法
*注意：抽象类可以继承抽象类
3.代码展示
Animal类
package 抽象;
public abstract class Animal {
//抽象方法，没有方法体，并且含有抽象方法的类必须是抽象类
public abstract void eat();
public void sleep() {
System.out.println("动物睡觉");
}
}Pig类
package 抽象;
public class Pig extends Animal {
public void eat() {
System.out.println("猪吃饭");
}
public void sleep() {
System.out.println("猪睡觉");
}
}Test类
package 抽象;
public class Test {
public static void main(String[] args) {
Person p=new Person();
p.eat();
}
}
五、接口
如果抽象类里面全部都是抽象方法，我们称之为接口。
接口其实就是抽象类的特殊化，可以看成纯粹的抽象类
不能使用class来修饰，改用interface来修饰
public interface Test{
//抽象方法
}
1.接口含有的成员
①属性：只能含有公有的静态的常量
public static final String name="Test";
通常我们直接写 String name="Test";
因为接口的属性默认为public static final，我们可以省略不写
②方法：只能是共有的抽象方法
注意：1.8版本default修饰具体方法
③块
不能含有块
④构造方法
没有构造方法
2.接口特点
不能创建对象，只能通过子类多实现（implements）来做事
public class A implements B,C,D{
}
* 注意：接口不能继承别的类
接口可以多继承接口
3.代码展示
package 抽象;
public interface TestInterface {
//属性
public static final String name="Test";
/*
* 通常我们直接写 String name="Test";
* 因为接口的属性默认为public static final，我们可以省略不写
*/
String name1="Test";
//方法
public abstract void eat();
//1.8版本新特性
public default void sellp() {}
//不能有块
// {
//
// }
//不能有构造方法
// public TestInterface() {}
}
以上就是对于final、static、abstract、接口的介绍
如果对你有帮助，可以点赞关注呦！！！
扫一扫
700
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
