Java_面向对象的 static 和 abstract

最新推荐文章于 2023-11-22 13:38:17 发布

weixin_43641389

最新推荐文章于 2023-11-22 13:38:17 发布

阅读量148

点赞数

本文深入解析Java中static和abstract的使用，包括静态属性、静态方法、静态代码块、静态内部类以及抽象类和抽象方法的概念与应用。通过具体代码示例，详细阐述了它们的特点、作用范围和生命周期。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

static:表示静态的
　　static:可以用来修饰属性、方法、代码块（或初始化块）、内部类。

    一、static修饰属性（类变量）：

public class TestStatic {
//static修饰属性
private static int id;
//static修饰方法
public static void getId(){ System.out.println(id); }
//static修饰代码块
static{ System.out.println(id); }
//static修饰内部类
static class A{ private String name; }
}

1.由类创建的所有的对象，都共用这一个属性。

2.当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。 VS 实例变量（非 static 修饰的属性，各个对象各自拥有一套副本）。

A a1 = new A();
a1.setId(1001);
System.out.println(a1.getId());//a1输出为1001
A a2 = new A();
System.out.println(a2.getId());//a2输出也为1001
System.out.println(a1.getId() == a2.getId());//输出为true

3.类变量随着类的加载而加载，而且单独一份。

4.静态的变量可以直接通过 “类.类变量” 的形式来调用。

5.类变量的加载要早于对象。所以当有对象以后，可以 “对象.类变量” 使用，但是 “类.实例变量” 是不行的。

public class TestStatic {
public static void main(String[] args) {
//“类.类变量” 调用
System.out.println(A.id);
// “对象.类变量” 调用
A a1 = new A();
System.out.println(a1.id);
}
}
class A{
public static int id = 1001;
public static int getId() { return id; }
public static void setId(int id) { A.id = id; }
}

6.类变量存在于静态域中。

    二、static修饰方法（类方法）：

1.随着类的加载而加载，在内存中也单独一份。

2.可以直接通过 “类.类方法” 的方式调用。

    //"类.类方法" 调用静态方法
    A.setId(1002);

3.内部可以调用静态的属性或静态的方法，而不能调用非静态的属性和方法。反之，非静态的方法是可以调用静态的属性和方法。

4.静态的方法内不可以有 this 或 super 关键字的！

class A{
public static int id = 1001;
private String name;

public static int getId() {
    //test();                 静态方法不可以调用非静态的属性和方法
    //this.name = "小明";     静态的方法内不可以有 this 或 super 关键字的！
    return id;    
}
public void test(){
    //非静态的方法是可以调用静态的属性和方法
    A.id = 1002;
    getId();
}

}

注：静态的结构（static 的属性、方法、代码块、内部类）的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构。

public class TestStatic {
public static void main(String[] args) {
B b = new B();
b.test(); //输出结果是什么？
}
}

class A{
static{
System.out.println(“A”);
}
public A(){
System.out.println(“B”);
}
}

class B extends A{
static{
System.out.println(“C”);
}
public B(){
System.out.println(“D”);
}
public void test(){
System.out.println(“E”);
}
}

//输出结果的顺序为：A ——> C ——> B ——> D ——> E

abstract:表示抽象的
　　abstract:可以用来修饰类和方法。

abstract class A{
public abstract void test();
}

    一、abstract 修饰类：抽象类

1.不可被实例化。（不能 new)

2.抽象类有构造器。（凡是类都有构造器）

3.抽象方法所在的类，一定是抽象类。

abstract class A{
public abstract void test();
public A(){} //抽象类有构造器
}

4.抽象类中可以没有抽象方法。

abstract class K{
public void test(){ System.out.println(“抽象类中可以没有抽象方法”); }
}

5.当我们设计一个类，不需要创建此类的实体的时候，就可以考虑将其设置为抽象的，由其子类实现这个类的抽象方法以后，就进行实例化。

     二、abstract 修饰方法：抽象方法

1.抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由子类重写此抽象方法。

2.若子类继承抽象类，并重写了所有的抽象方法，则此类是一个 “实体类” ，既可以实例化。

3.若子类继承抽象类，但是没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的类。

public class TestAbstract {
public static void main(String[] args) {
//People p = new People(); 抽象类不可被实例化
Worker w = new Worker();
w.show();
w.test();
}
}

abstract class People{
public abstract void test();
public abstract void show();
}

class Worker extends People{

public Worker(){}
@Override
public void test() {
    System.out.println("重写 test() 方法");
}

@Override
public void show() {
    System.out.println("重写 show() 方法");
}

}

原文：https://www.cnblogs.com/HHHY/p/10859626.html