final,static,抽象

最新推荐文章于 2024-11-11 21:19:25 发布
最新推荐文章于 2024-11-11 21:19:25 发布
阅读量732 收藏 29
点赞数 20
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64426680/article/details/142342033
版权

包（package）

什么是包？

包本质上就是文件夹，作用是对类进行分类管理。
开发中，经常会出现同名的类，如果没有包对他们进行区分，他们是没有办法共存的。有了包，我 们可以把同名的类放在不同的包里，这样就不会出现冲突。

包的定义

包的定义格式：

package 包名;  //多级包用.分隔，包名使用小写字母书写

示例：

package com.hualan.oop;

由于包是用于分类管理类的，因此类要定义在包中。即在类定义代码的上面，定义所在的包。

例如：

package com.hualan.weapon;//此处定义了Weapon类位于com.hualan.weapon包中

public class Weapon {
    //属性
    private String name;    //名称
    private int ap;         //攻击力
    private int price;      //价钱

    //getter和setter
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAp() {
        return ap;
    }

    public void setAp(int ap) {
        this.ap = ap;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    //构造方法
    public Weapon() {
        super();
    }

    public Weapon(String name, int ap, int price) {
        super();
        this.name = name;
        this.ap = ap;
        this.price = price;
    }

    public void showInfo() {
        System.out.println("名称：" + name + ",攻击力：" + ap + ",价格：" + price);
    }
}

导包

先看一个案例，通过案例了解什么是导包。

1. 需求：Student类所属的包是com.hualan.bean，ClassTest类所属的包是com.hualan.main，即Student类和ClassTest类不在同一个包中，在ClassTest的main方法中创建Student对象，并测试Student对象的功能。

2. 代码：

Student类：

package com.hualan.bean;

public class Student {
    public void study() {
        System.out.println("Good good study, day day up!");
    }
}

ClassTest类：

package com.hualan.main;

public class ClassTest {
    public static void main(String[] args) {
        Student stu = new Student();//此处代码会报错！原因是不认识Student类
        stu.study();
    }
}

修改后的ClassTest类：

package com.hualan.main;

public class ClassTest {
    public static void main(String[] args) {
        com.hualan.bean.Student stu = new com.hualan.bean.Student();//给出类的完整路径后，错误就消失了，而且程序可以正常运行。
        stu.study();
    }
}

类的完整限定名：这种包名.类名的写法称为类的完整限定名。

简化方式，提前引入Student类。

package com.hualan.main;
import com.hualan.bean.Student;//引入Student类，这就是导包。或者import 
com.hualan.bean .*;

public class ClassTest {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.study();
    }
}

导包的语法格式：

import 包名.类名;
或者
import 包名.*;

不推荐import 包名.*;

因为他是把包内所有的类都导入进来了。

java.lang包下的类不用导包。

同一个包内的类不用导包

示例：

import com.hualan.bean.Student;

访问修饰符

Java中提供了4种权限访问修饰符（从小到大）：private、缺省（default）、protected、public

4种修饰符可以修饰类以及类的成员（属性、方法、构造方法）。

1. 如果修饰类：只能使用public和缺省。

2. 如果修饰类的成员：private、缺省、protected、public都可以。

访问修饰符修饰类

public class A {

}
class B{

}

public修饰的类可以在任何地方使用（所属的包，以及其他包）。

缺省权限的类只能在本包中使用。

假如上述的A类位于com.hualan.package1包中，你可以在com.hualan.package1包中的其他类中创建A类对象，A a = new A(); 也可以在其他包中创建A类对象，例如在com.hualan.package2包中的类里创建A类对象， import com.hualan.package1.A; A a = new A();

但是B类只能在com.hualan.package1包中创建对象。你可以在com.hualan.package1包中的其他类中创建B类对象，B b = new B(); 不能在其他包中创建B类对象， 例如在com.hualan.package2包中的类里创建B类对象， import com.hualan.package1.B; B b = new B(); //代码会报错

访问修饰符修饰类的成员

类的成员：指的是类中定义的属性，方法。

private、缺省、protected、public会影响所修饰的属性和方法的可见度（访问权限）。

1. 在类内部，4种访问权限修饰的成员都可以访问。（指的是可以通过对象.属性名或者对象.方法名()这种形式访问属性和方法）

package com.hualan.p1;

public class A {
    private int a;
    int b;
    protected int c;
    public int d;

    private void privateMethod() {
    }

    void method() {
    }

    protected void protectdMethod() {
    }

    public void publicMethod() {
    }

    private A() {
    }

    A(int x) {
    }

    protected A(int x, int y) {

    }

    public A(int x, double y) {

    }


    public void test() {
        this.a = 100;
        this.b = 200;
        this.c = 300;
        this.d = 400;

        A a1 = new A();
        A a2 = new A(100);
        A a3 = new A(100, 200);
        A a4 = new A(100, 3.5);

        this.privateMethod();
        this.method();
        this.protectdMethod();
        this.publicMethod();
    }

}

2. 在同包的其他类中，缺省、protected、public修饰的成员可以访问。（指的是可以通过对象.属性名或者对象.方法名()这种形式访问属性和方法）

public class TestA {
    public static void main(String[] args) {
        //A a1 = new A();//private修饰的构造方法在同包其他类中不能用！
        A a2 = new A(100);
        A a3 = new A(100, 200);
        A a4 = new A(100, 3.5);

        //a4.a = 100;//private修饰的属性在同包的其他类中不能使用。
        a4.b = 200;
        a4.c = 300;
        a4.d = 400;

        //a4.privateMethod();//private修饰的方法在同包其他类中不能使用
        a4.method();
        a4.protectdMethod();
        a4.publicMethod();
    }
}
package com.hualan.p1;
 
public class SubA extends A {
    public SubA() {
        super(100);
    }

    public void test() {
        //this.a = 100;//在同包子类中，不能访问private修饰的属性
        this.b = 200;
        this.c = 300;
        this.d = 400;
        
        //A a1 = new A();//在同包子类中，不能访问private修饰的构造方法
        A a2 = new A(100);
        A a3 = new A(100, 200);
        A a4 = new A(100, 3.5);
        
        //this.privateMethod();//在同包子类中，不能访问private修饰的方法
        this.method();
        this.protectdMethod();
        this.publicMethod();
    }
}

3. 不同包的子类中，protected、public修饰的成员可以访问。（指的是可以通过对象.属性名或者对象.方法名()这种形式访问属性和方法）

package com.hualan.p2;

import com.hualan.p1.A;

public class SubA extends A {

    public SubA() {
        super(100, 200);
    }

    public void test() {
        //this.a = 100;
        //this.b = 200;
        this.c = 300;
        this.d = 400;

        //A a1 = new A();//在不同包的子类中，private修饰的构造方法不能使用
        //A a2 = new A(100);//在不同包的子类中，缺省的构造方法不能使用
        A a3 = new A(100, 200);
        A a4 = new A(100, 3.5);

        //this.privateMethod();//在不同包的子类中，private修饰的方法不能使用；
        //this.method();//在不同包的子类中，缺省的方法不能使用；
        this.protectdMethod();
        this.publicMethod();
        //      a4.privateMethod();
        //      a4.method();
        //a4.protectedMethod();
        a4.publicMethod();
    }
}

4. 不同包的无关类，public修饰的成员可以访问。（指的是可以通过对象.属性名或者对象.方法名()这种形式访问属性和方法）

package com.hualan.p2;
 
import com.hualan.p1.A;

public class ClassTest {
    public static void main(String[] args) {
        //A a1 = new A();//private修饰的构造方法在不同包其他类中不能用！
        //A a2 = new A(100);//缺省的构造方法在不同包其他类中不能用！
        //A a3 = new A(100, 200);
        A a4 = new A(100, 3.5);

        //a4.a = 100;//private修饰的属性在不同包的其他类中不能使用。
        //a4.b = 200;//缺省的属性在不同包的其他类中不能使用。
        //a4.c = 300;//protected修饰的属性在不同包的其他类中不能使用
        a4.d = 400;

        //a4.privateMethod();//private修饰的方法在不同包其他类中不能使用
        //a4.method();//缺省的方法在不同包其他类中不能使用
        //a4.protectdMethod();//protected修饰的方法在不同包其他类中不能使用
        a4.publicMethod();
    }
}

一般类都用public修饰。属性用private修饰，getter、setter用public修饰，构造方法一般使用public修饰，方法一般是public，个别不想暴露的方法用private。

final关键字

final单词的含义是最终的，在Java中final可以修饰类，方法，变量（实例变量，局部变量）。

final修饰类

final修饰类：说明类是最终的类，即类不能有子类。换句话说就是类不能被继承。

package com.hualan.testfinal;
 
public final class A {

}

package com.hualan.testfinal;
 
public class B extends A{//会报错

}

final修饰方法

final修饰方法：说明方法是最终的方法，即方法不能被子类重写。

package com.hualan.testfinal;

public class AA {
    public final void test() {
        System.out.println("这是final修饰的方法，不允许被重写");
    }
}
package com.hualan.testfinal;

public class BB extends AA {
    public void test() {//此处会报错！
        System.out.println("这是子类实现");
    }
}

final修饰变量（实例变量、局部变量）

final修饰变量：说明变量是最终的，即变量的值不能发生变化。（如果变量没赋值，有一次赋值机会）。

package com.hualan.testfinal;
 
public class AAA {
    private final int A = 100;

    public void method() {
        A = 200;//此处会报错！
    }
}
package com.hualan.testfinal;

public class TestFinal {
    public static void main(String[] args) {
        final int A;
        A = 10;
        A = 20;//此处会报错
    }
}
package com.hualan.testfinal;

public class TestFinal {
    public static void main(String[] args) {
        final int A = 10;
        A = 20;//此处会报错
    }
}

因为final修饰的变量，值不能发生变化，所以我们通常把final修饰的变量称为常量，变量名一般用纯大写命名。

static关键字

static单词的含义是静态的。在Java中static可以修饰属性、方法、代码块、内部类。

static修饰属性

如果属性用static修饰，那么这个属性不再是实例变量，而是类变量。

实例变量，即实例的变量，有多少个实例就有多少个变量

类变量，即类的变量，这个类所有的实例共用这个变量。

package com.hualan.teststatic;

public class Person {
    private String name;//姓名
    private int age;//年龄
    public static String nationality; //国籍

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public Person() {
        super();
    }

    public void showInfo() {
        System.out.println(name + "," + age + "," + nationality);
    }
}
package com.hualan.teststatic;

public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person("张三", 21);
        p1.nationality = "中国";//p1设置国籍以后，p2也会是这个国籍
        p1.showInfo();
        Person p2 = new Person("李四", 20);
        p2.showInfo();
        p2.nationality = "美国";//p2改变国籍，p1也会改变国籍
        p2.showInfo();
        p1.showInfo();
    }
}

被static修饰的属性，既可用对象访问，也可以用类访问。类属性应该使用类去访问，不要使用对象去访问（尽管可以）。

package com.hualan.teststatic;

public class PersonTest {

    public static void main(String[] args) {
        Person p1 = new Person("张三", 21);
        p1.nationality = "中国";//p1设置国籍以后，p2也会是这个国籍
        p1.showInfo();

        Person p2 = new Person("李四", 20);
        p2.showInfo();
        p2.nationality = "美国";//p2改变国籍，p1也会改变国籍
        p2.showInfo();
        p1.showInfo();

        Person.nationality = "朝鲜";
        p2.showInfo();
        p1.showInfo();
    }
}

static修饰方法

如果方法用static修饰，那么这个方法不再是实例方法，而是类方法。

实例方法：实例的方法，即对象的方法。由对象来调用方法。

类方法：类的方法，这个类所有的对象共用这个方法。

package com.hualan.teststatic;

public class Person {
    private String name;    //姓名
    private int age;        //年龄
    public static String nationality; //国籍

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public Person() {
        super();
    }

    public void showInfo() {
        System.out.println(name + "," + age + "," + nationality);
    }

    //静态方法（类方法）
    public static void staticMethod() {
        System.out.println("这是静态方法。");
    }
}
 package com.hualan.teststatic;

 public class PersonTest {

    public static void main(String[] args) {
        Person p1 = new Person("张三", 21);
        p1.staticMethod();//p1可以调用静态方法
        Person p2 = new Person("李四", 20);
        p2.staticMethod();//p2也可以调用静态方法
    }
}

被static修饰的方法，既可以被对象访问，也可以被类访问。类方法应该使用类去访问，不要使用对象去 访问（尽管可以）。

package com.hualan.teststatic;

public class PersonTest {
 
    public static void main(String[] args) {
        Person p1 = new Person("张三", 21);
        p1.staticMethod();//p1可以调用静态方法
        Person p2 = new Person("李四", 20);
        p2.staticMethod();//p2也可以调用静态方法
        
        Person.staticMethod();
    }
}

静态方法中不能访问实例变量

package com.hualan.teststatic;

public class Person {
    private String name;    //姓名
    private int age;        //年龄
    public static String nationality; //国籍

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public Person() {
        super();
    }

    public void showInfo() {
        System.out.println(name + "," + age + "," + nationality);
    }

    //静态方法（类方法）
    public static void staticMethod() {
        System.out.println("这是静态方法。");
        System.out.println(name);//此处会报错！
        name = "王五";//此处会报错！
        showInfo();//此处会报错！
    }
}

静态方法中，访问实例变量会报错。之所以报错是因为，静态方法是类方法，不是实例方法，因此访问实例变量的时候，不知道是访问的是哪个对象的实例变量。

静态方法中，访问实例方法会报错。之所以报错是因为，静态方法中访问实例方法，不知道访问的是哪个对象的实例方法。

静态方法中，不能使用this。this是一个代表当前方法调用者的对象。因为类通常是用类名调用的，不是具体的对象，所以不能用this。

static总结

1. static修饰的属性和方法被所有对象共享，即可以被对象访问。

2. static修饰的属性和方法可以被类访问。推荐使用类去访问静态属性和静态方法。

3. 静态方法中只能访问静态属性和静态方法。

代码块

用{}括起来的代码叫做代码块。

在Java中一共3种代码块：

1. 局部代码块

2. 初始化代码块

3. 静态代码块。

局部代码块

定义在方法体内的代码块叫局部代码块。

public class BlockTest {
    public static void main(String[] args) {
        int a = 10;
        {
            int b = 20;
            System.out.println(a);
            System.out.println(b);
        }
        //System.out.println(b);//此处会报错。
    }
}

上面的代码，在main方法中定义了一个局部代码块。代码块外定义的变量可以在代码块中使用，但代码块内定义的变量不能在代码块外使用，即代码块内的变量作用域仅限于代码块内。

局部代码块平时很少使用。switch..case中具体的case可以使用，可以避免多个case定义相同的变量出现重名的问题。

初始化代码块

初始化代码块是定义在类中的代码块。它和属性、方法、构造方法属于是一个层级的东西。由于通常用它来做初始化，所以叫做初始化代码块。

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person() {
        super();
        System.out.println("无参构造方法");
    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
        System.out.println("全参构造方法");
    }

    {
        name = "zhangsan";
        age = 20;
        System.out.println("这是一个初始化块！我 比 构造方法执行 先执行");
    }

    public void showInfo() {
        System.out.println("姓名： " + name + "，年龄：" + age);
    }
}

测试代码：

public class BlockTest {

    public static void main(String[] args) {
        Person p = new Person();
        p.showInfo();

        Person p2 = new Person("lisi", 22);
        p2.showInfo();
    }
}

初始化代码块作用：

1. 可以为属性赋值----等价于构造方法。

2. 可以做公共初始化。----如果多个构造方法，他们有共同的代码，共同的代码可以提到初始化代码块中。

初始化代码块的特点：

1. 初始化代码块定义格式和方法类似，只不过只有{}，没有参数，没有返回值。

2. 初始化代码块不能主动调用，创建对象的时候自动执行，先于构造方法执行。

3. 一个类中可以有多个初始化代码块，写在上面的初始化代码块先执行。尽管可以定义多个，一般最多定义一个。

静态代码块

用static修饰的代码块称为静态代码块。

静态代码块是类的代码块，随着类的加载而调用，因为类只会加载一次，所以静态代码块也只执行一次。

public class StaticBlock {
    public static int a = 100;
    private int b;

    public int getB() {
        return b;
    }

    public void setB(int b) {
        this.b = b;
    }

    //静态代码块
    static {
        System.out.println("静态代码块");
    }

    //初始化代码块
    {
        System.out.println("初始化代码块");
    }

    //构造方法
    public StaticBlock(int b) {
        super();
        this.b = b;
        System.out.println("有参构造方法");
    }

    public StaticBlock() {
        super();
        System.out.println("无参构造方法");
    }
}

测试代码：

public class BlockTest {
    
    public static void main(String[] args) {
        int num = StaticBlock.a;
        System.out.println(num);
        
        StaticBlock sb1 = new StaticBlock();
        StaticBlock sb2 = new StaticBlock(20);
    }
}

静态代码块的特点：

1. 静态代码块的书写格式和初始化代码块的格式类似，在前面加一个static关键字即可。

2. 静态代码块不能主动调用，类加载的时候自动调用。因为类只加载一次，所以只调用一次。

3. 静态代码块可以有多个，写在上面的先执行。一般最多只写一个。

4. 静态代码块中不可以使用实例变量，不可以调用实例方法。

5. 静态代码块比初始化代码块先执行。

继承关系里，代码块执行顺序

父类Father：

public class Father {
    static {
        System.out.println("父类--静态代码块");
    }

    {
        System.out.println("父类----初始化代码块");
    }

    public Father() {
        super();
        System.out.println("父类------构造方法");
    }
}

子类Son：

public class Son extends Father {
    static {
        System.out.println("zi类--静态代码块");
    }

    {
        System.out.println("zi类----初始化代码块");
    }

    public Son() {
        super();
        System.out.println("zi类------构造方法");
    }
}

测试类：

public class BlockTest {

    public static void main(String[] args) {
        Son s = new Son();
        System.out.println("==========");
        Son s2 = new Son();
    }
}

在继承关系里，创建子类对象时，会先加载类，再创建对象。

加载类时，先加载父类，再加载子类。--- 类只有首次用的时候才加载，加载之后就一直在内存中。

创建对象时，先执行父类的初始化代码块和构造方法，再执行子类的初始化代码块和构造方法。

abstract关键字

abstract单词的含义是抽象。它可以用来修饰方法，也可以用来修饰类。被abstract修饰的类称为抽象类，被abstract修饰的方法称作抽象方法。

抽象类

抽象类最大的特点就是不能实例化对象，即不能创建对象。

public abstract class Animal {

}

测试代码：

public class ClassTest {

    public static void main(String[] args) {
        Animal a = new Animal();//会报错
    }

}

抽象类有什么用？

有些时候，父类只是为了被子类继承，在用的时候，我们希望别人用子类，而不是用父类，这个时候，我们就可以把父类定义成抽象类。

例如：Animal只是表示动物，即使创建了对象也没有什么意义，我们更希望创建的是猫、狗等更具体的对象。为了防止别人误用，防止创建Aninal对象，我们可以通过abstract把Animal定义为抽象类，这样别人就无法创建Animal对象了。

抽象类中可以定义属性、方法吗？

能！一个普通类能包含的内容，抽象类都能包含。

抽象类和普通类的唯一区别就是不能创建对象。---我不能创建对象，但是我东西可以被子类继承呀！

public abstract class Animal {
    //属性
    private String name;
    private int age;
    //常量
    public static final int TEST = 100;
    //静态属性
    public static int test;

    //setter、getter
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //构造方法
    public Animal() {
        super();
    }

    public Animal(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    //静态代码块
    static {
        System.out.println("静态代码块");
    }

    //初始化代码块
    {
        System.out.println("初始化代码块");
    }

    //实例方法
    public void eat() {
        System.out.println("吃东西");
    }

    //静态方法
    public static void staticMethod() {
        System.out.println("静态方法");
    }
}

抽象方法

抽象方法：被abstract修饰的方法。

抽象方法必须定义在抽象类中！

抽象方法不能有方法实现！

public abstract class Animal {
    public abstract void eat();
}

抽象方法有什么用？

抽象方法是专门为多态设计的！是专门设计用来被子类重写的！

Animal做为动物类，它比较抽象，即使实现了eat方法，也会被子类重写，不如不实现。只定义出来有这个一个方法，但不实现，由具体的子类来实现。

如果一个类继承于抽象类，那么必须实现抽象类中所有的抽象方法！

或者自己也定义成抽象类，由自己的子类来实现抽象方法！

Cat类实现Animal类的抽象方法：

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

}

Cat类不实现Animal类的抽象方法：

public abstract class Cat extends Animal {

}

子类BosiCat实现抽象方法：

public class BosiCat extends Cat {

    @Override
    public void eat() {
        System.out.println("波斯猫吃鱼");
    }

}

抽象类不能创建对象怎么办？

可以借助多态，用子类创建对象，抽象类的引用指向子类创建的对象。

public class ClassTest {
    
    public static void main(String[] args) {
        Animal a = new BosiCat();
        a.eat();
    }
    
}

实例

1. 需求：定义一个Person类，完成饲养猫，饲养狗的功能。设计猫和狗类的时候，使用抽象和继承完成。

2. 代码：

父类Animal：

public abstract class Animal {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Animal() {
        super();
    }

    public Animal(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    //声明抽象方法  eat
    public abstract void eat();

    public void showInfo() {
        System.out.println(name + "," + age + "岁");
    }
}

Cat类：

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public Cat() {
        super();
    }

    public Cat(String name, int age) {
        super(name, age);
    }

}

Dog类：

public class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public Dog() {
        super();
    }

    public Dog(String name, int age) {
        super(name, age);
    }

}

Person类：

public class Person {
    public void raiseAnimal(Animal animal) {
        animal.eat();
    }
}

测试代码：

public class ClassTest {

    public static void main(String[] args) {
        Animal a1 = new Cat("花花", 2);
        Animal a2 = new Dog("旺财", 5);
        a1.eat();
        a2.eat();
        System.out.println("----------");
        Person p = new Person();
        p.raiseAnimal(a1);
        p.raiseAnimal(a2);
    }
}

总的来说：抽象类属于类的设计层面上的问题。它是为了设计类而存在，不是为了创建对象而存在。它最佳的使用场景就是多态。

抽象类声明子类必须要实现的方法（即自身的抽象方法），子类根据自己特征实现父类中声明的抽象方法。在创建和使用对象的时候，借助多态，用父类引用指向子类对象。这样可以充分发挥多态的优势。

总结

1. 包的本质是文件夹。如果要使用的类是本包中的类，无需导包可以直接使用。如果要使用的类不是本包中的类，需要导包，或者使用类的完整限定名。导包语法：import 包名.类名; 或者import 包名.*; 位于java.lang包中的类无需导包。

2. 属性通常使用private修饰，方法通常使用public修饰，不想对外暴露的方法使用private修饰。

3. final修饰类，类不能被继承（不能有子类）；final修饰方法，方法不能被子类重写；final修饰属性，属性不能修改值（必须给一个初始值），final修饰局部变量，局部变量只能赋值一次。

4. static修饰的属性会成为类属性，通常用类名访问；static修饰的方法会成为类方法，通常用类名访问。

5. 静态代码块随着类的加载而执行，类只加载一次，静态代码块也只执行一次。初始化代码块，在创建对象的时候执行，并且先于构造方法执行。局部代码块能改变局部变量的作用域。

6. abstract修饰的类是抽象类，抽象类不能创建对象，抽象类通常作为父类，用于被子类继承。抽象类主要使用场景是多态，父类类型指向子类对象。abstract修饰的方法是抽象方法，抽象方法只能存在于抽象类（或接口）中。抽象方法主要是由子类实现。

超高校级の程序员
关注
专栏目录
final 与 static 的区别
ConstXiong
04-11 1万+
final 与 static 的区别 都可以修饰类、方法、成员变量。 static可以修饰类的代码块，final不可以。 static不可以修饰方法内的局部变量，final可以。 static修饰表示静态或全局，被修饰的属性和方法属于类，可以用类名.静态属性 / 方法名 访问 static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块,只会被执行一...
java final static顺序_java语言中 public static final的顺序在执行过程中有什么区别吗？...
weixin_42236014的博客
02-16 1245
final:final可以用来修饰：类、属性和方法用于修饰类：表示该类不可以被继承用于修饰属性：表示该属性不可以被修改用于修饰方法：表示该方法不可以被重写但是，final不可以用于修饰接口和抽象类staticstatic可以用作修饰：类、属性、方法、代码块用于修饰类：普通类不允许声明为静态的，只有内部类才可以。被static修饰的内部类可以直接作为一个普通类来使用。而不需要实例一个外部类用于修饰属...
static final
weixin_50998882的博客
03-28 999
实例变量 变量属于对象所有 ​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​ 类变量变量属于类所有 静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。 静态变量初始化的时机在成员变量之前： 类加载：java源程序xxx.java----&...
java抽象类,static静态,final
weixin_61557810的博客
04-26 990
抽象类,static静态,final
JAVA的final与static
dlz_yhn的博客
05-12 5367
static static是静态的意思，也是全局的意思。static定义的东西，属于全局，与类相关，不与具体实例相关，是类实例之间共享的。 1. 被static修饰的变量属于类变量，可以通过类名.变量名直接引用，而不需要new出一个对象来 2. 被static修饰的方法属于类方法，可以通过类名.方法名直接引用，而不需要new出一个对象来 static与非static的区别： 在内存中存放的位置不同：所有static修饰的属性和方法都放在内存的方法区（内存的方法区相当于常驻内存，如果一个方法或者变量
static java 内存_final, static,final static 分别放在jvm内存的什么地方?
weixin_39946327的博客
02-20 3999
比如我写一个类：publicclassJvmTest{publicstaticStringst_static="hellostatic";publicfinalStringst_final="hellofinal";publicstaticfinalStringst_final_str="hellofinalstatic";publicstatic...
抽象方法能否被private、static、final关键字修饰？
qq_45376750的博客
06-18 2473
不可以，抽象方法存在的目的就是被子类重写，而private的方法是不能被子类重写的，所以不能修饰 不可以，抽象方法存在的目的就是被子类重写，而的方法是不能被子类重写的，所以不能修饰 不可以，抽象方法存在的目的就是被子类重写，而private的方法是不能被子类重写的，所以不能修饰 ...
final和static的区别
m0_61545566的博客
07-11 2749
static：final：
final 和 static 关键字
m0_71791722的博客
07-28 1383
声明数据为常量，可以是编译时常量，也可以是在运行时被初始化后不能被改变的常量。// x = 2;y.a = 1;。private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法签名相同，此时子类的方法不是重写基类方法，而是在子类中定义了一个新的方法。。
抽象类能使用 final 修饰吗？
热门推荐
ConstXiong
04-18 2万+
抽象类能使用 final 修饰吗？ 不能，抽象类是被用于继承的，final修饰代表不可修改、不可继承的。 【Java面试题与答案】整理推荐 基础与语法 集合 网络编程 并发编程 Web 安全 设计模式 框架 算法与数据结构 异常 文件解析与生成 Linux MySQL Oracle Redis Dubbo ...
Java final static abstract关键字概述
09-02
Java编程语言中的`final`, `static`, 和 `abstract` 是三个非常重要的关键字，它们分别用于定义不同的特性。接下来，我们将详细探讨这些关键字的作用及其应用场景。 ### 抽象类（abstract） 1. **定义**：当一个类...
PHP中abstract(抽象)、final(最终)和static(静态)原理与用法详解
10-15
在PHP编程语言中，`abstract`、`final`和`static`是三个非常重要的关键字，它们分别用于定义抽象类和方法、限制类和方法的继承以及实现静态成员。接下来我们将详细探讨这三个关键字的原理和用法。 1. `abstract`...
继承，重载，重写，多态，抽象类，接口，final，static
08-13
继承，重载，重写，多态，抽象类，接口，final，static
java中final和static的区别
03-24
Java 中 final 和 static 的区别 final 关键字在 Java 中有多种用法，包括修饰变量、方法、类等。下面是 final 关键字的各种用法： 1. final 修饰变量：表示该变量一旦被初始化，程序无法修改变量的值，该变量变成...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 192
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
SpringBoot 实现图片加水印
最新发布
心猿意码
11-11 296
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 290
顺序算法题----力扣刷题
JAVA-01-变量
LJH_laura_li的博客
11-08 475
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 303
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值