上海市城乡住房建设厅网站,卓辉科技 网站建设,wordpress获得授权,做网站界面用什么软件1.Java修饰符语法知识点及案例代码
Java修饰符用于改变类、方法、变量、接口等元素的行为和可见性。主要分为两大类#xff1a;访问修饰符和非访问修饰符。
访问修饰符#xff08;Access Modifiers#xff09; public 提供最大的访问权限#xff0c;任何类都可以访问。使…1.Java修饰符语法知识点及案例代码
Java修饰符用于改变类、方法、变量、接口等元素的行为和可见性。主要分为两大类访问修饰符和非访问修饰符。
访问修饰符Access Modifiers public 提供最大的访问权限任何类都可以访问。使用对象类、方法、变量、接口、构造方法。 protected 对同一包内的类和所有子类可见。使用对象变量、方法、构造方法不能修饰类。 default无修饰符 在同一包内可见。使用对象类、接口、变量、方法、构造方法。 private 在同一类内可见。使用对象变量、方法、构造方法不能修饰类。
非访问修饰符Non-Access Modifiers static 修饰类变量和方法表示属于类本身而不是某个实例。类变量在方法区存储所有对象共享。静态方法不能访问非静态成员。 final 修饰类、方法和变量表示不可更改。类不能被继承。方法不能被重写。变量常量不可修改。 abstract 修饰类和方法表示抽象没有具体实现。抽象类不能被实例化。抽象方法必须由子类实现。 synchronized 修饰方法或代码块用于处理多线程并发访问资源时的同步控制。 volatile 修饰变量确保线程间的可见性和防止指令重排序。 transient 修饰变量表示该变量不会被序列化机制处理。 native 修饰方法表示该方法由非Java代码实现通过JNI调用。 strictfp 修饰类或方法表示浮点数运算遵循严格的IEEE 754标准。
案例代码
// 访问修饰符示例
public class AccessModifiersDemo {// 默认访问修饰符包访问权限int defaultVar 10;// 私有访问修饰符private int privateVar 20;// 受保护访问修饰符protected int protectedVar 30;// 公共访问修饰符public int publicVar 40;// 公共方法public void printVars() {System.out.println(Default Var: defaultVar);System.out.println(Private Var: privateVar);System.out.println(Protected Var: protectedVar);System.out.println(Public Var: publicVar);}// 私有方法外部类不能直接访问private void privateMethod() {System.out.println(This is a private method.);}// 公共静态方法public static void staticMethod() {System.out.println(This is a static method.);}// 主方法public static void main(String[] args) {// 创建对象AccessModifiersDemo demo new AccessModifiersDemo();// 访问公共和默认变量System.out.println(Accessing publicVar: demo.publicVar);// System.out.println(Accessing defaultVar: demo.defaultVar); // 错误不能在外部类中直接访问默认访问修饰符的变量// 调用公共方法demo.printVars();// 调用静态方法staticMethod();// 由于privateMethod是私有的因此不能直接调用// demo.privateMethod(); // 错误privateMethod() 不能被访问}
}// 非访问修饰符示例
abstract class Shape {// 抽象方法abstract void draw();
}class Circle extends Shape {// 实现抽象方法Overridevoid draw() {System.out.println(Drawing a Circle.);}
}class Rectangle extends Shape {// 实现抽象方法Overridevoid draw() {System.out.println(Drawing a Rectangle.);}
}class FinalDemo {// final变量final int CONSTANT 100;// final方法final void finalMethod() {System.out.println(This is a final method.);}
}class StaticDemo {// 静态变量static int staticVar 5;// 静态方法static void staticMethod() {System.out.println(This is a static method. Static Var: staticVar);}
}public class NonAccessModifiersDemo {public static void main(String[] args) {// 创建Circle和Rectangle对象Shape circle new Circle();Shape rectangle new Rectangle();// 调用draw方法circle.draw();rectangle.draw();// FinalDemo示例FinalDemo finalDemo new FinalDemo();System.out.println(Final Constant: finalDemo.CONSTANT);finalDemo.finalMethod();// StaticDemo示例System.out.println(Accessing static variable: StaticDemo.staticVar);StaticDemo.staticMethod();}
}在以上代码中AccessModifiersDemo 类展示了不同访问修饰符的用法NonAccessModifiersDemo 类展示了非访问修饰符的用法。
以下是一些具体的Java修饰符使用案例包括访问修饰符和非访问修饰符的示例。
访问修饰符案例
1. 公共类与公共方法
// 公共类
public class PublicClassDemo {// 公共变量public int publicVar 10;// 公共方法public void publicMethod() {System.out.println(This is a public method. Public Var: publicVar);}// 主方法public static void main(String[] args) {// 创建对象并访问公共成员PublicClassDemo demo new PublicClassDemo();demo.publicMethod();System.out.println(Accessing publicVar: demo.publicVar);}
}2. 私有成员与公共方法访问
// 公共类
public class PrivateMemberDemo {// 私有变量private int privateVar 20;// 公共方法访问私有变量public void accessPrivateVar() {System.out.println(Private Var: privateVar);}// 主方法public static void main(String[] args) {// 创建对象并调用公共方法访问私有变量PrivateMemberDemo demo new PrivateMemberDemo();demo.accessPrivateVar();// demo.privateVar; // 错误无法从外部访问私有变量}
}3. 受保护成员与继承
// 基类
public class ProtectedMemberBase {// 受保护变量protected int protectedVar 30;// 受保护方法protected void protectedMethod() {System.out.println(Protected Var: protectedVar);}
}// 子类
public class ProtectedMemberDerived extends ProtectedMemberBase {// 主方法public static void main(String[] args) {// 创建子类对象并访问受保护成员ProtectedMemberDerived derived new ProtectedMemberDerived();derived.protectedMethod();System.out.println(Accessing protectedVar: derived.protectedVar);}
}非访问修饰符案例
1. 静态成员与静态方法
// 公共类
public class StaticMemberDemo {// 静态变量static int staticVar 40;// 静态方法static void staticMethod() {System.out.println(Static Var: staticVar);}// 主方法public static void main(String[] args) {// 直接访问静态成员无需创建对象System.out.println(Accessing static variable: StaticMemberDemo.staticVar);StaticMemberDemo.staticMethod();// 也可以通过对象访问静态成员不推荐StaticMemberDemo demo new StaticMemberDemo();System.out.println(Accessing static variable through object: demo.staticVar);demo.staticMethod();}
}2. 最终变量与方法
// 公共类
public class FinalMemberDemo {// 最终变量常量final int FINAL_CONSTANT 50;// 最终方法不能被重写public final void finalMethod() {System.out.println(This is a final method. Final Constant: FINAL_CONSTANT);}// 主方法public static void main(String[] args) {// 创建对象并访问最终成员FinalMemberDemo demo new FinalMemberDemo();demo.finalMethod();// demo.FINAL_CONSTANT 100; // 错误不能修改最终变量}
}3. 抽象类与抽象方法
// 抽象基类
public abstract class AbstractClassDemo {// 抽象方法无实现public abstract void abstractMethod();// 具体方法有实现public void concreteMethod() {System.out.println(This is a concrete method.);}
}// 具体子类
public class AbstractClassDerived extends AbstractClassDemo {// 实现抽象方法Overridepublic void abstractMethod() {System.out.println(Implementing abstract method.);}// 主方法public static void main(String[] args) {// 创建子类对象并调用方法AbstractClassDerived derived new AbstractClassDerived();derived.abstractMethod();derived.concreteMethod();}
}这些案例涵盖了Java中常见的修饰符使用场景包括访问修饰符public、private、protected、默认和非访问修饰符static、final、abstract的示例。通过运行这些代码你可以更好地理解修饰符在Java中的作用和用法。 在Java中私有成员使用private修饰符和非访问修饰符如static、final、abstract等是两种不同的概念但它们可以组合使用。以下是一些示例展示了私有成员与非访问修饰符的结合使用。
私有成员与static修饰符
public class PrivateStaticExample {// 私有静态变量private static int privateStaticVar 100;// 私有静态方法private static void privateStaticMethod() {System.out.println(Private static method called. Private static variable: privateStaticVar);}// 公共静态方法用于访问私有静态成员public static void accessPrivateStatic() {privateStaticMethod();System.out.println(Accessing private static variable: privateStaticVar);}// 主方法public static void main(String[] args) {// 通过公共静态方法访问私有静态成员PrivateStaticExample.accessPrivateStatic();// 不能直接从类外部访问私有静态成员// System.out.println(PrivateStaticExample.privateStaticVar); // 错误无法从外部访问私有静态变量// PrivateStaticExample.privateStaticMethod(); // 错误无法从外部访问私有静态方法}
}私有成员与final修饰符
public class PrivateFinalExample {// 私有最终变量常量private final int PRIVATE_FINAL_CONSTANT 200;// 构造函数public PrivateFinalExample() {// 注意不能在构造函数中重新赋值给final变量除非是在初始化块中但这里已经初始化了// this.PRIVATE_FINAL_CONSTANT 300; // 错误不能重新赋值给final变量}// 公共方法用于展示私有最终变量的值public void showPrivateFinalConstant() {System.out.println(Private final constant: PRIVATE_FINAL_CONSTANT);}// 主方法public static void main(String[] args) {// 创建对象并调用方法PrivateFinalExample example new PrivateFinalExample();example.showPrivateFinalConstant();// 不能从类外部直接访问私有最终变量// System.out.println(example.PRIVATE_FINAL_CONSTANT); // 错误无法从外部访问私有最终变量}
}注意abstract修饰符不能用于成员变量
abstract修饰符只能用于类和方法不能用于成员变量。因此你不能有一个“私有抽象成员变量”。但是你可以有一个抽象类其中包含私有成员变量和抽象方法。
抽象类中的私有成员
public abstract class AbstractClassWithPrivateMembers {// 私有成员变量private int privateMemberVar 300;// 抽象方法无实现public abstract void abstractMethod();// 具体方法可以访问私有成员变量public void showPrivateMemberVar() {System.out.println(Private member variable: privateMemberVar);}
}// 具体子类
public class ConcreteClassDerivedFromAbstract extends AbstractClassWithPrivateMembers {// 实现抽象方法Overridepublic void abstractMethod() {System.out.println(Abstract method implemented.);}// 主方法public static void main(String[] args) {// 创建子类对象ConcreteClassDerivedFromAbstract concrete new ConcreteClassDerivedFromAbstract();// 调用具体方法访问私有成员变量通过继承关系concrete.showPrivateMemberVar();// 调用实现的抽象方法concrete.abstractMethod();// 不能从子类外部直接访问父类的私有成员变量// System.out.println(concrete.privateMemberVar); // 错误无法从外部访问私有成员变量即使是通过子类对象}
}这些示例展示了如何在Java中结合使用私有成员和非访问修饰符。私有成员保证了封装性而非访问修饰符则提供了额外的功能或限制。
