三个修饰符

最新推荐文章于 2022-07-20 22:54:02 发布
最新推荐文章于 2022-07-20 22:54:02 发布
阅读量560 收藏 2
点赞数
分类专栏： JavaSe 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40055163/article/details/120201165
版权

三个修饰符

  • 学习目标
    认识每种修饰符的可以修饰组件。
了解每种修饰符修饰组件时的特点。
概念较多，注意记录。
    使用修饰符可以让程序设计的更加合理，通常起到优化的作用。

1 abstract

  • 概念：抽象。
  • 可以修饰的组件：类、方法。
1.1 abstract修饰类
  • 概念：abstract 修饰的类称为抽象类。
  • 抽点类特点：只能声明引用不能创建对象。
    演示的代码如下：
package com.txw.test;
public class TestAbstractClass{
	public static void main(String[]args){		
		MyClass mc;		// 声明引用
		// mc = new MyClass();		// 创建对象
		// mc = new Sub();
		// mc = new MyClass();
		mc = new Sub();
		mc.m1();
	}
}
// 抽象类
abstract class MyClass{
	int a;   // 属性
	public void method(){}		// 方法
	public MyClass(){}			// 构造方法
	public abstract void m1(); // 抽象方法
}
// 抽象方法也可以被继承
class Sub extends MyClass{
	// 子类覆盖父类的抽象方法,添加{ }
	public void m1(){
		System.out.println("m1()");
	}
}
1.2 abstract修饰方法

  • 概念：abstract 修饰的方法称为抽象方法。

  • 抽象方法的语法：

    访问权限修饰符 abstract 返回值类型 方法名(参数表);

  • 抽象方法的特点：

    1. 抽象方法没有{}(实现/方法体)。
      比如：
      public abstract void method();
    2. 抽象方法只能存在抽象类中。
      abstract class MyClass{
	public abstract void m1();		// 抽象方法
}
    3. 抽象方法可以被继承，子类不覆盖抽象方法，子类必须为抽象类。
      abstract class Super{
    // 抽象方法
    public abstract void method();
}
// 子类没有覆盖抽象方法，子类必须为抽象类
abstract class Sub extends Super{
    
}
    4. 子类不想称为抽象类，必须覆盖父类中的所有抽象方法并添加{}（实现）。
      abstract class Super{
    // 抽象方法
    public abstract void method();
}
// 子类没有覆盖抽象方法，子类必须为抽象类
class Sub extends Super{
    // 覆盖父类中的抽象方法,添加{}
    public void method(){ 
    }
}
      子类覆盖父类的抽象的方法，这种特殊的语法称为实现 抽象方法即为办成品方法，父类提供声明（我要做什么），子类提供方法实现（我要怎么做）。

  • 总结：

    1. abstract可以修饰类、方法，被修饰的类称为抽象类，方法称为抽象方法。
2. 抽象类：只能声明引用，不能创建对象。
2. 抽象方法：只有方法声明没有方法实现，必须存在于抽象类中，子类继承父类如果父类中有抽象方法则子类也会称为抽象类
           子类不想称为抽象类，必须覆盖父类中的抽象方法并添加实现，这种特殊的覆盖语法称为实现。

2 final

  • 概念：最终的。
  • 可以修饰的组件：类、方法、成员变量（属性）、局部变量 。
2.1 final修饰局部变量

  • final修饰的局部变量称为常量。

  • 特点：值不可变，基本数据类型值为数据，引用数据类型值为地址。

    final int a = 10;		// 定义变量并赋值
a=10;		// 改变变量的值,Error 常量无法改变值
System.out.println( a );
2.2 final修饰成员变量

  • final修饰的成员变量称为成员常量（常量）。

  • 特点：值不可变，且没有默认值，必须手动赋值。
    演示：使用初始化方式直接赋值。

    class MyClass{
	// 常量属性
	final int a = 10;
}

    演示：使用动态初始化代码块赋值

    class MyClass{
	
	// 常量属性
	final int a;
	// 动态初始化代码块，初始化属性时自动执行
	// 作用为属性赋值
	// 与构造方法的作用一样
	{
		// 使用初始化代码块初始化属性
		a = 10;
	}
}

演示：使用构造方法为属性赋值，务必保证每个构造方法中都有赋值语句。

class MyClass{
	// 常量属性
	final int a;
	// 使用构造方法为属性赋值
	public MyClass(){
		a = 10;
	}
	public MyClass(int a){
		this.a  = a;
	}
}
2.3 final修饰方法
  • final修饰的方法称为最终方法。
  • 特点：不能被子类覆盖。
    class Super{
	public final void method(){}
}
class Sub extends Super{
	// 覆盖错误
	public void method(){}
}
2.4 final修饰类
  • final修饰的类称为最终类。
  • 特点：不能被继承。
    final class Super{
	public  void method(){}
}
class Sub extends Super{        // Error 不能继承final类
	// 覆盖
	public void method(){}
}
  • 总结：
    final表示最终的，可以修饰类、方法、成员变量、局部变量。
1. 修饰类：称为最终类，不能被继承。
2. 修饰方法：称为最终方法，不能被覆盖。
3. 修饰属性：常量属性（成员常量），必须手动赋值，可以通过初始化赋值、动态初始化代码块赋值、构造方法赋值，值能赋值一次，值不可变。
4. 修饰局部变量：常量（局部常量），只能赋值一次，值不可变，基本数据类型值为数据，引用数据类型值为地址。
``

package com.txw.test;
public class TestFinal{
	public static void main(String[]args){
		// final int a = 10;	// 定义变量并赋值
		// a=10;	// 改变变量的值
		// System.out.println( a );
		// final int[] as = new int[3];
		// System.out.println( as );
		// as[0] = 10;
		// as = new int[5];
		// System.out.println(as[0]);
		MyClass mc = new MyClass();
		System.out.println( mc.a );
	}
	
}
// 分配空间 为属性分配默认值
// 初始化属性 为属性赋予初值，执行动态初始化代码块
// 调用构造方法
class MyClass{
	// 常量属性
	final int a;
	// 使用构造方法为属性赋值
	public MyClass(){
		a = 10;
	}
	public MyClass(int a){
		this.a  = a;
	}
}
final class Super{
	public  void method(){}
}
class Sub extends Super{
	// 覆盖
	public void method(){}
}

3 static

  • 概念：static表示静态的，与对象无关的。
  • 可以修饰的组件：import、类、属性、方法、动态初始化代码块。
3.1 static修饰属性

  • static修饰的属性称为静态属性。

  • 特点：与对象无关，可以直接使用类名访问。

  • 语法如下：

    类名.静态属性名

    演示的代码如下：

    class MyClass{
	int a;
	static int b;	// 静态属性
}
MyClass.b  = 10;		// 使用类名直接访问静态属性

    注意：静态属性也可以通过对象的引用访问但不推荐，静态属性存放在共享空间中与对象不在一块内存空间。

3.2 static修饰方法
  • static修饰的方法为静态方法。
  • 特点：与对象无关，可以使用类名直接访问。
  • 语法如下：
    访问权限修饰符 static 返回值类型 方法名(参数表){
    
}
    演示的代码如下：
    class MyClass{
	int a;
	static int b;		// 静态属性
	// 一般方法
	public void m1(){
		System.out.println("m1() in MyClass");
	}
	// 静态方法
	public static void m2(){
		System.out.println("static m2() in MyClass");
	}
}

MyClass.m2(); 						// 调用静态方法
    注意：
    1. 静态方法与对象无关，所以无需创建对象直接使用，不依赖对象所以无法使用this（当前对象）与super（父类对象）关键字。
2. 静态方法与对象无关，所以不能使用非静态成员（成员变量，成员方法）。
3. 静态方法可以被继承，只能被静态方法覆盖，使用子类类名直接访问继承到的静态方法。
4. 静态方法与对象无关，所以不能使用多态。
    静态方法通常用于工具方法，因为调用便捷。
3.3 static修饰动态初始化代码块
  • static修饰的动态初始化代码块称为静态初始化代码块。
  • 特点：在第一次使用一个类时执行一次。
  • 语法如下：
    // 在类以内，方法以外的位置
static{
    
}
    执行时机高于构造方法，第一次创建对象时先执行静态初始化代码块。
    使用触发条件：
    1. 第一次创建对象时。
2. 第一次使用静态成员时（静态属性，静态方法）。
3. 第一次创建子类对象时，第一次使用子类静态成员时。
    只声明引用，不算使用，不可触发静态初始化代码块。
    注意：在静态初始化代码块中，不能使用非静态成员（成员变量，成员方法）。
  • 创建对象的过程：
    1. 分配空间
2. 执行父类静态初始化代码块（第一次创建）。
3. 执行子类静态初始化代码块（第一次创建）。
4. 初始化父类属性、
5. 调用父类构造方法。
6. 初始化子类属性。
7. 调用子类构造方法。
    演示的代码如下：
package classes;
public class TestStatic{
	public static void main(String[]args){
		// 访问a属性
		// MyClass mc = new MyClass();
		// mc.a = 100;
		// MyClass.b = 10;
		// MyClass mc1 = new MyClass();
		// mc1.a = 300;
		// MyClass.b  = 20;
		// 访问b静态属性
		// System.out.println( MyClass.b );
		// System.out.println( MyClass.b );
		// MyClass mc = new MyClass();
		// mc.m1();		// 调用方法
		// MyClass.m2();
		// Sub.m2();
		MyClass mc = null;
		// mc.m1();
		// mc.m2(); 
	}
}
class MyClass{
	int a;
	static int b;			// 静态属性
	public void m1(){
		System.out.println("m1() in MyClass");
	}
	// 静态方法
	public static void m2(){
		// System.out.println( a );
		// m1();
		// System.out.println( b );
		System.out.println("static m2() in MyClass");
	}
}
class Sub extends MyClass{
	public void m1(){
		System.out.println("m1() in Sub");
	}
	
	public static void m2(){
		System.out.println("m2() in Sub");
	}	
}
4 import static 静态引入
  • 引入外部的静态资源，使用时可以省略类名.。
    演示的代码如下：
package com.txw.test;
import static java.util.Arrays.sort;
import static java.lang.System.out;
import java.util.Arrays;
public class TestStatic2{
	public static void main(String[]args){
		// MyClass mc;
		// new MyClass();
		// new MyClass();
		// MyClass.m1();
		// MyClass.m1();
		// new Sub();
		int[] a = {6,4,2,1,2,3,4,2};
		// 排序
		sort( a );
		System.out.println( Arrays.toString( a ) );
	}
}
class Super{
	// 静态初始化代码块
	static{
		System.out.println("Super static{ }");
	}
	
	public Super(){
		System.out.println("Super()");
	}
}
class Sub extends Super{
	static{
		System.out.println("Sub static{ }");
	}
	public Sub(){
		System.out.println("Sub () ");
	}
}

5 习题

  1. 关于三个修饰符描述不正确的是(AD)。
    A. static 可以修饰所有类型的变量。
    B. static 可以修饰方法 C. final 可以修饰类。
    D. abstract 可以修饰类、方法、属性。
    原因：A错误static修饰不了局部变量 D错误abstract只能修饰类和方法。
  2. 下面关于 static 描述不正确的是© 。
    A. static 修饰的属性称为静态变量，被所有的对象共享。
    B. static 修饰的方法，可以直接用 类名.方法名(参数)调用。
    C. static 修饰的方法中可以直接访问本类的其他方法 。
    D. 父类中定义了 static 修饰的方法，子类中不能再定义同名的 static 方法。
    原因：C错误静态方法中只能直接访问静态成员
  3. 关于 final 描述错误的是(AB)。
    A. final 修饰的类是作用范围内常量，只允许一次赋值。
    B. final 修饰的方法不能被继承 。
    C. final 修饰的方法不允许被覆盖。
    D. final 修饰的类没有子类。
  4. 关于 abstract，以下选项正确的是：A,B,C,D
    A. abstract 类中可以没有 abstract 方法 。
    B. abstract 类的子类也可以是 abstract 类。
    C. abstract 类不能创建对象，但可以声明引用。
    D. abstract 方法不能有方法体 。
  5. 仔细阅读以下程序，写出程序输出的结果。
    在这里插入图片描述
    答： 300 200 300 400 静态属性是所有对象共享，一方修改影响另一方。实例属性随着创建对象的个数每个对象都拥有一份。
  6. 仔细阅读以下程序，选出哪些代码会导致程序出错() 。在这里插入图片描述
    A. // 1
    B. // 2
    C. // 3
    D. // 4
    E. // 5
    F. // 6
    G. // 7
    H. // 8
    原因：静态方法中只能直接访问静态成员。
  7. 仔细阅读以下程序，写出程序运行输出的结果。
    在这里插入图片描述
    答：
    In Static
    MyClass()
    20
    MyClass(int)
    10
  8. 仔细阅读以下代码，关于代码描述正确的是© 。
    在这里插入图片描述
    A. 编译通过，输出 10。
    B. 编译不通过，把第 2 行改为 final int value = 10;
    C. 编译不通过，把第 3 行改为 public MyClass(){ value = 10; }
    D. 以上描述都不正确。
    原因：final修饰的属性，如果在构造方法中赋值，那么每一个构造方法都应该有赋值语句。
  9. 仔细阅读以下代码，关于以下程序描述正确的是©。
    在这里插入图片描述
    A. 编译不通过 。
    B. 编译通过；在//1 处加上：mv.value = 200; 则编译不通过。
    C. 编译通过。如果在//1 处加上：mv = new MyValue(); 则编译不通过。
    D. 以上描述都不正确 。
  10. 仔细阅读以下代码，选出正确选项(A)。在这里插入图片描述
    A. 编译通过 。
    B. // 1出错 。
    C. // 2 出错 。
    D. // 3 出错。
    E. // 4 出错 。
    原因：Final所修饰的变量并没有改变值，编译可以通过。
  11. 仔细阅读以下代码，代码中哪些内容是错误的(BC)。 在这里插入图片描述
    A. // 1
    B. // 2
    C. // 3
    D. // 4
    原因：B错误因为抽象方法没有方法体。
    C错误子类覆盖父类方法访问修饰符要么和父类一致要么更宽。
  12. 仔细阅读以下代码，程序是否能编译通过？如果可以，输出运行结果；如果不可以，应该怎样修改？
    在这里插入图片描述
    答：
    可以编译通过，输出结果：
    m1() in Super
    m1(int) in Sub
    m1(double) in Sub
    注意：父类有 m1 方法，并且是 final 的，子类也有 m1 方法，但是子类的 m1 方法和父类的 m1 方法不构成方法覆 盖。
    13 . 仔细阅读以下程序，写出程序运行输出的结果。
    在这里插入图片描述
    答：m1 in Super
    m2 in Sub
    m1 in Sub
    m2 in Sub
    注意：静态方法没有多态。
  13. 下面关于方法声明正确的是(E)。
    A. abstract final void m()
    B. public void final m()
    C. static abstract void m()
    D. private abstract void m()
    E. public static final void m()
  14. 判断以下描述是否正确，正确填 T；否则填 F。
    (1) abstract 可以修饰类、方法、属性（F）
    (2) 抽象类中不一定有构造方法（E）
    (3) 抽象类只能声明引用，不允许单独 new 对象（T）
    (4) 所有类中都可以定义抽象方法（F）
    (5) 子类继承抽象类必须实现抽象类中所有抽象方法（F）
    (6) static 可以修饰属性、方法、代码块（T）
    (7) 静态属性只能用 类名.静态属性名 访问 （F）
    (8) 静态方法可以被本类中的其他方法直接访问（T）
    (9) 静态代码在创建对象时完成静态属性的初始化工作（F）
    (10)final 只能修饰属性、方法、类（F）
    (11)final 修饰的方法不能被继承（F）
    (12)final 修饰的类不能被继承，即没有子类（T）
  15. 把三大特性中的 Shape 类改为抽象类，并把其中的求周长和求面积的方法改为抽象方法。
    演示的代码如下：
package com.txw.test;

abstract class Shape{
    abstract public double girth(); 
    abstract public double area(); 
}
class Circle extends Shape{ 
    private double radius;
    private double pi = 3.1415926;
    
    public Circle(double radius) { 
        this.radius = radius;
    }
    
    public double area() {
        return pi * radius * radius;
    }
    
    public double girth() {
        return 2 * pi * radius; 
    }
}
class Rect extends Shape{ 
    private double a;
    private double b; 
    public Rect(){
        
    } 
    
    public Rect(double a, double b) { 
        this.a = a;
        this.b = b;
    }
    
    public double area() { 
        return a * b;
    }
    
    public double girth() { 
        return 2 * (a + b);
    } 
}
class Square extends Rect{ 
    private double a;
    
    public Square(double a) { 
        super(); 
        this.a = a;
    }
    
    public double area() {
        return a * a;
    }
    
    public double girth() {
        return 4 * a;
    } 
}
  1. 设计一个类 MyClass，为 MyClass 增加一个 count 属性，用来统计总共创建了多少个对象。
    演示的代码如下：
package com.txw.test;

public class MyClass { 
    private int count = 0;
    public MyClass(){
        count ++;
}
public int getCount(){
        return count;
    }
}

6 总结

请简述三个修饰符可修饰的组件与各自的作用。

1. abstract 可以修饰类，方法，被修饰的类只能声明引用不能创建对象，被修饰的方法只有方法声明没有方法实现，只能存在抽象类中。
2. final 可以修饰类，方法，成员变量，局部变量。
		 修饰类：不能被继承。
		 修饰方法：不能被覆盖。
		 修饰成员变量：必须手动赋值，可以通过初始化赋值、动态初始化代码块赋值、构造方法赋值，只能赋值一次，值不能变。
		 修饰局部变量：只能赋值一次，值不能变，基本数据类型值为数据，引用数据类型值为地址。		 
3. static 可以修饰 import , 类, 属性，方法，动态初始化代码块。
		修饰属性：静态属性与对象无关，通过类名直接访问。
		修饰方法：静态方法与对象无关，通过类名直接访问。
		修饰动态初始化代码块：静态初始化代码块，第一次使用一个类时自动调用。
		修饰import：静态引入（import static），可以引入外部的静态资源，使用时不用明确类名。

关于修饰符连用：

1. abstract 不能与 final、static、private一起使用。
2. static与final都能修饰属性与方法，可以一起使用，修饰的属性为静态常量。

如图所示：在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

学无止路
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 三个修饰符习题.zip
05-12
该文件主要是测试初学者对java三个修饰符的理解是否完善，能很好的测试出测试者是否对三个java三个修饰符有很好的理解。
三个修饰符（abstract、static、final）
最新发布
qq_50856002的博客
07-23 468
(1) 被 abstract修饰的类称为抽象类(2) 抽象类可以声明引用，但是不能创建对象(3) 抽象类中可以定义 成员变量、成员方法(4) 抽象类中可以定义构造方法，构造方法用于子类创建对象时完成父类对象时应用(1) 被final修饰的变量作用范围内的常量，允许一次赋值，不允许被修改 【重点】(2) 被final修饰的实例变量不再具有默认值，初始化的时机： 【了解】a. 定义的同时对其初始化b. 在构造方法中，对其初始化。
三个修饰符（abstract，static，final）
zhang666zhang的博客
11-05 308
一、 abstract(抽象的)     1. abstract 修饰的类称为抽象类。    ① 抽象类不能单独创建对象，只能声明引用。    ② 抽象类中可以定义成员变量、成员方法。    ③ 抽象类中有构造方法，但是构造不是单独创建对象时使用，       而是创建子类对象，先去创建父类时，子类调用。    2. abstract 修饰的方法称为抽象方法。        ① 抽
三大修饰符总结
12-22
今天就所学知识, 对Java中三个修饰符做一个简单的总结 abstract关键字(要求子类强制重写父类的方法) abstract使用总结: 1. abstract修饰的方法没有方法体 2. abstract修饰的方法必须定义在abstract修饰的类内或者...
java练习题chp7_三个修饰符.pdf
03-11
java练习题chp7 Key Point ●static ●final ●abstrac
三个修饰符(abstract、static、final)
12-21
abstract abstract修饰类 (1) 被abstract修饰的类是抽象类,编译后生成独立class文件 (2) 抽象类不能单独new对象,但可以声明引用 ...(1) 如果一个类继承抽象类，此类为抽象类的子类 (2) 如果子类不想
Chp8 三个修饰符.pdf
11-25
java基础教材 讲解通俗易懂 非常适合初学者学习
三大修饰符（abstract、final、static）
lmz的博客
07-20 433
java三大修饰符
三个修饰符（abstract static final）
weixin_46663595的博客
05-12 206
第九章:三个修饰符(abstract. static)加粗样式 -、asbtract(类、 方法) 二、static (属性、方法、静态代码块) 三、final(最终的、最后的) [相关语法理解掌握] final可以修饰符变量(局部变量、实例变量、静态变量)(1) final修饰的变量是作用范围内的常量,只允许- -次赋值,不允许更改注意: final|修饰的变量 通常以全大写字母作为名字 (2) final修饰实例变量，jvm不再分配默认值final修饰实例变量初始化的位置:a.在声明的同时给其初始化b
09_三个修饰符
m0_45044194的博客
07-18 138
百知教育 - 胡鑫喆 - 09_三个修饰符 01_abstract语法 abstract类： 可以声明引用，不能创建对象。 abstract方法： 只有声明，没有实现 （大括号用 分号 取代）。 注意： 如果一个类拥有抽象方法，这个类 必须是抽象类，抽象类未必有抽象方法。 子类继承一个抽象类，如果子类不希望也成为抽象类，就必须实现父类中所有的抽象方法。 代码： package ...
三大修饰符详细解释。
冰蛙
07-28 652
一.abstract 抽象的 1.方法 被abstract所修饰的方法 被称为抽象方法 a)语法： abstract放置在方法的返回值类型之前 并且与访问权限修饰符顺序无要求 抽象方法没有方法的实现部分 连{}都没有 public abstract double area(); public abstract double girth(); 2.类 站在语法的角度：被 abstract所修饰的类被称为抽象类 ​ 站在使用的角度：只能被声明 不能被实例化的类 被称为抽象类 a)语法： abstrac
Java的数据结构
热门推荐
weixin_40055163的博客
03-07 1万+
1 数据结构简介 1.1 什么是数据结构 简单地说，数据结构是以某种特定的布局方式存储数据的容器。这种“布局方式”决定了 数据结构对于某些操作是高效的，而对于其他操作则是低效的。所以我们需要理解各种数据 结构，才能在处理实际问题时选取最合适的数据结构。 数据结构=逻辑结构+物理结构（顺序、链式、索引、散列） 。 逻辑结构：数据元素间抽象化的相互关系 。 物理结构：（存储结构），在计算机存储器中的存储形式。 2 数据结构逻辑分类 数据结构从逻辑上划分为三种基本类型： 2.1 线性结构 数据结构中的元素存在一
面向对象编程思想
weixin_40055163的博客
09-08 4949
面向对象编程思想（Object Oriented Programming） 面向过程编程思想面向过程核心思想：自顶向下，逐步求精。 面向对象编程思想面向对象核心思想：以对象为单位，将解决客观世界问题的方式方法引入到编程领域中。 面向对象编程是面向过程的一种升级。 1 什么是对象？ 概念：由于计算机不断地发展需要计算机解决人类在现实世界中的问题，所以必须在程序中模拟出客观世界存在事物，而对象就是对事物的一种统称 一句话总结：万物皆对象，一切客观存在的事物在面向对象思想中统称为对象。 1.1
Java的容器
weixin_40055163的博客
03-04 4609
1 容器简介 容器，是用来容纳物体、管理物体。生活中,我们会用到各种各样的容器。如锅碗瓢盆、 箱子和包等。如图所示： 程序中的“容器”也有类似的功能，用来容纳和管理数据。比如，如下新闻网站的新闻 列表、教育网站的课程列表就是用“容器”来管理： 视频课程信息也是使用“容器”来管理： 开发和学习中需要时刻和数据打交道，如何组织这些数据是我们编程中重要的内容。我 们一般通过“容器”来容纳和管理数据。事实上，我们前面所学的数组就是一种容器，可以 在其中放置对象或基本类型数据。 数组的优势：是一种简单的线性序列
数组 (Array)
weixin_40055163的博客
02-21 3371
1 数组的概念 1.1 数组的定义 数组的定义 数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先 后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标） 来访问它们。数组的四个基本特点： 1.长度是确定的。数组一旦被创建，它的大小就是不可以改变的。 2.其元素的类型必须是相同类型，不允许出现混合类型。 3.数组类型可以是任何数据类型，包括基本类型和引用类型。 4.数组变量属于引用类型，数组也是对象。 建议: 数组变量属于引用类型，数组也是对象，数组中的
Java三个修饰符教学目标
05-09
Java中有许多修饰符，但其中最常见的三个修饰符是public、private和protected。它们的教学目标如下： 1. 理解访问控制 public、private和protected是Java中的访问修饰符，它们用于控制类、方法和变量的访问权限。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学无止路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值