本篇文章给大家带来了关于java的相关知识,详细介绍了Java中static关键字和内部类的使用,文中的示例代码讲解详细,下面一起来看一下,希望对大家有帮助。
本篇文章给大家带来了关于java的相关知识,详细介绍了Java中static关键字和内部类的使用,文中的示例代码讲解详细,下面一起来看一下,希望对大家有帮助。 推荐学习:《java视频教程》 一. static 关键字在Java中,被static修饰的成员,称之为静态成员,也可以称为类成员,其不属于某个具体的对象,是所有对象所共享的。 1. static修饰成员变量static修饰的成员变量,称为静态成员变量 【静态成员变量特性】:
public class Student{ public String name; public String gender; public int age; public double score; public static String classRoom = "rj2104"; public Student(String name, String gender, int age, double score) { this.name = name; this.gender = gender; this.age = age; this.score = score; } // ... public static void main(String[] args) { // 静态成员变量可以直接通过类名访问 System.out.println(Student.classRoom); Student s1 = new Student("Li leilei", "男", 18, 3.8); Student s2 = new Student("Han MeiMei", "女", 19, 4.0); Student s3 = new Student("Jim", "男", 18, 2.6); // 也可以通过对象访问:但是classRoom是三个对象共享的 System.out.println(s1.classRoom); System.out.println(s2.classRoom); System.out.println(s3.classRoom); } } 2. static修饰成员方法一般类中的数据成员都设置为private,而成员方法设置为public, Java中,被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有的。 静态成员一般是通过静态方法来访问的。 public class Student2{ // ... private static String classRoom = "rj2104"; // ... public static String getClassRoom(){ return classRoom; } } class TestStudent { public static void main(String[] args) { System.out.println(Student2.getClassRoom()); } } 【静态方法特性】:
3. static成员变量的初始化静态成员变量一般不会放在构造方法中来初始化,构造方法中初始化的是与对象相关的实例属性 静态成员变量的初始化分为两种:就地初始化 和 静态代码块初始化。 就地初始化:在定义时直接给出初始值 public class Student2{ // ... //就地初始化 private static String classRoom = "rj2104"; //... } 用静态代码块完成初始化 public class Student2{ // ... private static String classRoom; //静态代码块初始化 static { classRoom = "rj2104"; } // ... } 二. 内部类在 Java 中,可以将一个类定义在另一个类或者一个方法的内部, 前者称为内部类,后者称为外部类。内部类也是封装的一种体现。 内部类和外部类共用同一个java源文件,但是经过编译之后,内部类会形成单独的字节码文件, 一般形成的字节码文件文件名为:外部类名字$内部类名字.class public class OutClass { class InnerClass{ } } // OutClass是外部类 // InnerClass是内部类 根据内部类定义的位置不同,一般可以分为以下几种形式: 1.成员内部类(普通内部类) 实例内部类:未被static修饰的成员内部类 静态内部类:被static修饰的成员内部类 2.局部内部类 3.匿名内部类 1. 实例内部类即未被static修饰的成员内部类。 【注意事项】:
public class OutClass { private int a; static int b; int c; public void methodA() { a = 10; System.out.println(a); } public static void methodB() { System.out.println(b); } // 实例内部类:未被static修饰 class InnerClass { int c; //实例内部类当中 不能有静态的成员变量. 非要定义,那么只能是被static final修饰的 public static final int d = 6; public void methodInner() { // 在实例内部类中可以直接访问外部类中:任意访问限定符修饰的成员 a = 100; b = 200; methodA(); methodB(); System.out.println(d); // 如果外部类和实例内部类中具有相同名称成员时,优先访问的是内部类自己的 c = 300; System.out.println(c); // 如果要访问外部类同名成员时候,必须:外部类名称.this.同名成员名字 OutClass.this.c = 400; System.out.println(OutClass.this.c); } } public static void main(String[] args) { // 外部类:对象创建 以及 成员访问 OutClass outClass = new OutClass(); System.out.println(outClass.a); System.out.println(outClass.b); System.out.println(outClass.c); outClass.methodA(); outClass.methodB(); System.out.println("=============实例内部类的访问============="); // 要访问实例内部类中成员,必须要创建实例内部类的对象 // 而普通内部类定义与外部类成员定义位置相同,因此创建实例内部类对象时必须借助外部类 // 创建实例内部类对象 OutClass.InnerClass innerClass1 = new OutClass().new InnerClass(); innerClass1.methodInner(); // 上述语法比较怪异,也可以先将外部类对象先创建出来,然后再创建实例内部类对象 OutClass.InnerClass innerClass2 = outClass.new InnerClass(); innerClass2.methodInner(); } } 2. 静态内部类被static修饰的内部成员类称为静态内部类。、 【注意事项】: 在静态内部类中只能访问外部类中的静态成员,除非在内部类当中new一个外部类的对象,通过外部类对象的引用去访问其中的非静态成员。 创建静态内部类对象时,不需要先创建外部类对象 public class OuterClass2 { public int data1 = 1; int data2 = 2; public static int data3 = 3; public void test() { System.out.println("out::test()"); } // 静态内部类:被static修饰的成员内部类 static class InnerClass2 { public int data4 = 4; int data5 = 5; public static int data6 = 6; public void func() { System.out.println("out::func()"); //test(); // 编译失败,在静态内部类中不能直接访问外部类中的非静态成员 //System.out.println(data1); //System.out.println(data2); //外部类的非静态成员,需要通过外部类的对象的引用才能访问。 OuterClass2 outerClass = new OuterClass2(); System.out.println(outerClass.data1); System.out.println(outerClass.data2); outerClass.test(); // 在静态内部类中只能访问外部类的静态成员 System.out.println(data3); System.out.println(data4); System.out.println(data5); System.out.println(data5); System.out.println(data6); } } public static void main(String[] args) { // 静态内部类对象创建 和 成员访问 OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2(); innerClass2.func(); } } 3. 局部内部类定义在外部类的方法体或者{ }中,一般使用的非常少。 【注意事项】 局部内部类只能在所定义的方法体内部使用 不能被public、static等修饰符修饰 局部内部类生成的字节码文件稍有区别:外部类名字$数字内部类名字.class ppublic class OutClass { int a = 10; public void method(){ int b = 10; // 局部内部类:定义在方法体内部 // 不能被public、static等访问限定符修饰 class InnerClass{ public void methodInnerClass(){ System.out.println(a); System.out.println(b); } } // 只能在该方法体内部使用,其他位置都不能用 InnerClass innerClass = new InnerClass(); innerClass.methodInnerClass(); } public static void main(String[] args) { // OutClass.InnerClass innerClass = null; 编译失败 } } 4. 匿名内部类匿名内部类,就是没有名字的一种嵌套类 匿名内部类形成的字节码文件文件名为:外部类名字$数字.class 4.1 使用匿名内部的好处与演示 在实际开发中,我们会遇到下面的情况: 一个接口/类的方法的某个执行过程在程序中只会执行一次,但为了使用它,我们需要创建它的实现类/子类去实现/重写方法。 代码中为了这一次的使用去创建一个类,未免太过麻烦,此时就可以使用匿名内部类来解决这个问题 首先来看我们正常的实现逻辑,假设有一个接口,接口当中只有一个方法 public interface Interface { void show(); } 为了使用该接口的show方法,我们需要去创建一个实现类,重写show方法的具体实现 public class Test implements Interface{ @Override public void show() { System.out.println("只执行一次show()"); } } public class Main { public static void main(String[] args) { Test test = new Test(); test.show(); } } 如果实现类Test在程序中只使用一次,那么为了这一次的使用去创建一个类太过繁琐,这种情况下就可以用匿名内部类来实现,无需创建新的类,减少代码冗余, 看下面代码: class Main { public static void main(String[] args) { //写法一 Interface in = new Interface() { @Override public void show() { System.out.println("匿名内部类中重写show()"); } }; //调用接口方法 in.show(); //写法二 new Interface() { @Override public void show() { System.out.println("匿名内部类中重写show()"); } }.show();//调用接口方法 } } 4.2 匿名内部类的定义格式和使用 定义格式1:
定义格式2:
对格式“new 接口名称() {…}”的理解: new代表创建一个新的对象对象 接口名称就是匿名内部类需要实现哪个接口 {…}中是匿名内部类的内容 【注意事项】:
public class Class { public void show(String s){ System.out.println("Class::show()"); } } public abstract class AbstractClass { abstract void show(String s); } public interface Interface { void show(String s); } public class TestDome { public static void main(String[] args) { //重写普通类的方法 new Class(){ @Override public void show(String s) { System.out.println(s); } }.show("普通类"); //重写抽象类的抽象方法 new AbstractClass(){ @Override void show(String s) { System.out.println(s); } }.show("抽象类"); //实现接口的抽象方法 new Interface(){ @Override public void show(String s) { System.out.println(s); } }.show("接口"); } } 执行结果: 推荐学习:《java视频教程》 以上就是详解Java中static关键字和内部类的使用的详细内容,更多请关注模板之家(www.mb5.com.cn)其它相关文章! |