JAVA中的内部类和匿名类

java内部类练习题

内部类练习题 一、按要求填空 1.请在以下代码的基础上完成下面几个小题 （1）在①和②的位置标注出内部类和外部类 （2）在③的位置定义一个count变量用来存放Circle实例的个数，并在④的位置编写语句用来统计Circle实例的个数。 （3）在⑤和⑥处根据注释语句填写代码 （4）在main()⑦的位置上编写语句调用Draw类中的drawSahpe()。 （5）将修改后的完整代码拷贝在下方： class Circle { //① private double radius = 0; ③ public Circle(double radius) { this.radius = radius; ④ } class Draw { //② public void drawSahpe() { ⑤ //输出radius变量的值 ⑥ //输出count变量的值 } } } public class OuterInnerClass { public static void main(String[] args) { ⑦ //编写语句调用Draw类中的drawSahpe() } } 答案： class Circle { //①外部类 private double radius = 0; static int count=0; public Circle(double radius) { this.radius = radius; count++; } class Draw { //②内部类

public void drawSahpe() { System.out.println(radius); System.out.println(count); } } } public class OuterInnerClass { public static void main(String[] args) { Circle objCircle=new Circle(10); Circle.Draw objDraw=objCircle.new Draw(); objDraw.drawSahpe(); } } 2.程序填空，使程序运行结果为 30 20 10 public class Demo{ public static void main (String[] args) { Outer.Inner obj=new Outer().new Inner(); obj.show(); } } class Outer{ public int number=10; class Inner{ public int number=20; public void show() { int number=30; System.out.print( ); System.out.print( ); System.out.print( ); } } } 答案： public class Demo{ public static void main (String[] args) { Outer.Inner obj=new Outer().new Inner(); obj.show();

实验5 JAVA常用类

山西大学计算机与信息技术学院 实验报告 姓名学号专业班级 课程名称 Java实验实验日期成绩指导教师批改日期 实验5 JAVA常用类实验名称 一．实验目的： （1）掌握常用的String，StringBuffer(StringBuilder)类的构造方法的使用；（2）掌握字符串的比较方法，尤其equals方法和==比较的区别； （3）掌握String类常用方法的使用； （4）掌握字符串与字符数组和byte数组之间的转换方法； （5）Date，Math，PrintWriter，Scanner类的常用方法。 二．实验内容 1.二进制数转换为十六进制数（此程序参考例题249页9. 2.13） 程序源代码 import java.util.*; public class BinToHexConversion{ //二进制转化为十六进制的方法 public static String binToHex(String bin){ int temp; //二进制转化为十六进制的位数 if(bin.length()%4==0) temp = bin.length()/4; else temp = bin.length()/4 + 1; char []hex = new char[temp]; //十六进制数的字符形式 int []hexDec = new int[temp];//十六进制数的十进制数形式 int j = 0; for(int i=0;i=0&&dec<10) return (char)('0'+dec-0); else if(dec>=10&&dec<=15) return (char)('A'+dec-10); else return '@'; }

匿名内部类

中的匿名内部类总结 匿名内部类也就是没有名字的内部类 正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写 但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口 实例1:不使用匿名内部类来实现抽象方法 abstract class Person { public abstract void eat(); } class Child extends Person { public void eat() { System.out.println("eat something"); } } public class Demo { public static void main(String[] args) { Person p = new Child(); p.eat(); } } 运行结果：eat something 可以看到，我们用Child继承了Person类，然后实现了Child的一个实例，将其向上转型为Person 类的引用 但是，如果此处的Child类只使用一次，那么将其编写为独立的一个类岂不是很麻烦？ 这个时候就引入了匿名内部类 实例2：匿名内部类的基本实现 abstract class Person { public abstract void eat(); } public class Demo { public static void main(String[] args) { Person p = new Person() { public void eat() { System.out.println("eat something"); } }; p.eat(); } } 运行结果：eat something 可以看到，我们直接将抽象类Person中的方法在大括号中实现了 这样便可以省略一个类的书写

JAVA内部类的作用、方法、使用

引用：JAVA内部类的作用、方法、使用 今天，因为在程序中使用内部类[事件]，但要将外部类传递到调用类里面。 在内部类如何调用外部类，通过网络搜索，找到了方法： outclass.this，可以在内部类里引用外部类对象。 当然，还有其他的一些设计与说明，非常的好！ 内部类:一个内部类的定义是定义在另一个内部的类。 原因是: 1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。 2.对于同一个包中的其他类来说，内部类能够隐藏起来。 3.匿名内部类可以很方便的定义回调。 4.使用内部类可以非常方便的编写事件驱动程序。 提起Java内部类（Inner Class）可能很多人不太熟悉，实际上类似的概念在C++里也有，那就是嵌套类（Nested Class），关于这两者的区别与联系，在下文中会有对比。内部类从表面上看，就是在类中又定义了一个类（下文会看到，内部类可以在很多地方定义），而实际上并没有那么简单，乍看上去内部类似乎有些多余，它的用处对于初学者来说可能并不是那么显著，但是随着对它的深入了解，你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类，是掌握Java高级编程的一部分，它可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍： * 第一次见面 public interface Contents { int value(); } public interface Destination { String readLabel(); } public class Goods { private class Content implements Contents { private int i = 11; public int value() { return i; } } protected class GDestination implements Destination { private String label; private GDestination(String whereTo) { label = whereTo; }

Java常用类和方法面试题+答案

2015年12月20日18:25:21 Java常用类和方法重点总结 作者：数据分析玩家 1、简述Java中内存分配的问题 1>凡是new（）出来的东西，都是在堆中进行分配的 2>局部变量【数据类型+变量名】都是在栈中进行分配的 3>静态变量【static】和字符串常量【“String”】都是在数据区进行分配的 4>方法【代码】都是在代码区进行存放的 2、简述Java中Object类的地位 1>Java中所有的类【自己定义的类以及Sun公司提供的类】都默认自动继承了Object类 2>Java中所有的类都从Object类中继承了toString()方法、hashCode()方法和equals()等方法 3、简述Object类中toString()方法的注意事项 1>toString()方法的返回值是一个字符串 2>toString()方法返回的是类的名字和该对象的哈希码组 成的一个字符串，即toString()方法返回的是该对象的字符串表示形式 3>在Java中System.out.println(类对象名)实际输出的是该对象的toString()方法返回的字符串，即括号中的内容等价于类对象名.toString(),toString方法的好处是在碰到

println方法的时候会被自动调用，不用显示的写出来 4>建议所有的子类都重写从Object类中继承过来toString 方法，否则toString方法的返回值没有什么实际含义 4、简述Object类中equals()方法的注意事项 1>equals方法的返回值为true或false 2>Object类中equals方法只有在两个对象是同一块内存区域时，即不但内容相同、地址还必须相同时才返回true，否则即便内容相同、如果地址不同只会返回false 3>重写Object类中的equals方法目的在于：保证只要两个对象的内容相同，equals方法就返回true 5、简述Object类中hashCode()方法的注意事项 1>哈希码原本指的是内存空间地址的十六进制表示形式 2>hashCode()方法返回的是该对象的哈希码、即该对象的真实内存地址的十六进制表示形式，但是重写完hashCode()方法之后，返回的不再是该对象真实内存地址的十六进制表示形式 6、学习Java中toString方法、equals方法、hashCode方法共同的一个注意事项 在Java中，凡是动态分配的内存都是没有名字的，而是将其地址赋给一个指针变量【引用】，用指针变量去代表这个事物，所以引用和动态分配的内存有本质上的区别，但是在学习Java中的toString方法、equals方法和hashCode方

匿名内部类精讲

1.new父类构造器（参数列表）|实现接口（） 2.{ 3.//匿名内部类的类体部分 4.} 从上面定义可以看出，匿名内部类必须继承一个父类，或实现一个接口，但最多只能继承一个父类，或实现一个接口。 关于匿名内部类还有如下两条规则： 1）匿名内部类不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建内部类的对象。因此不允许将匿名内部类 定义成抽象类。 2）匿名内部类不等定义构造器，因为匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以定义实例初始化块， 通过实例初始化块来完成构造器需要完成的事情。 最常用的创建匿名内部类的方式是需要创建某个接口类型的对象，如下程序所示：[java]view plaincopy 1.interface Product{ 2.public double getPrice(); 3.public String getName(); 4.} 5.public class TestAnonymous{ 6.public void test(Product p){ 7. System.out.println("购买了一个"+p.getName()+"，花掉了 "+p.getPrice());

8. } 9.public static void main(String[]args){ 10. TestAnonymous ta = new TestAnonymous(); 11. ta.test(new Product(){ 12.public double getPrice(){ 13.return567; 14. } 15.public String getName(){ 16.return"AGP显卡"; 17. } 18. }); 19. } 20.} 上面程序中的TestAnonymous类定义了一个test方法，该方法需要一个Product对象作为参数，但Product只是一个接口， 无法直接创建对象，因此此处考虑创建一个Product接口实现类的对象传入该方法---如果这个Product接口实现类需要重复 使用，则应该经该实现类定义一个独立类；如果这个Product接口实现类只需一次使用，则可采用上面程序中的方式，定义 一个匿名内部类。 正如上面程序中看到，定义匿名类不需要class关键字，而是在定义匿名内部类时直接生成该匿名内部类的对象。上面 粗体字代码部分就是匿名类的类体部分。 由于匿名内部类不能是抽象类，所以匿名内部类必须实现它的抽象父类或者接口里包含的所有抽象方法。 对于上面创建Product实现类对象的代码，可以拆分成如下代码： [java]view plaincopy 1.class AnonymousProduct implements Product{ 2.public double getPrice(){ 3.return567; 4. } 5.public String getName(){ 6.return"AGP显卡"; 7. } 8. } 9. ta.test(new AnonymousProduct());

2019最新Java面试题,常见面试题及答案汇总

ava最新常见面试题+ 答案汇总 1、面试题模块汇总 面试题包括以下十九个模块：Java 基础、容器、多线程、反射、对象拷贝、Java Web 模块、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、Mybatis、RabbitMQ、Kafka、Zookeeper、MySql、Redis、JVM 。如下图所示： 可能对于初学者不需要后面的框架和JVM 模块的知识，读者朋友们可根据自己的情况，选择对应的模块进行阅读。 适宜阅读人群 需要面试的初/中/高级java 程序员 想要查漏补缺的人 想要不断完善和扩充自己java 技术栈的人 java 面试官 具体面试题 下面一起来看208 道面试题，具体的内容。 一、Java 基础 1.JDK 和JRE 有什么区别？ 2.== 和equals 的区别是什么？ 3.两个对象的hashCode()相同，则equals()也一定为true，对吗？ 4.final 在java 中有什么作用？ 5.java 中的Math.round(-1.5) 等于多少？ 6.String 属于基础的数据类型吗？ 7.java 中操作字符串都有哪些类？它们之间有什么区别？ 8.String str="i"与String str=new String(“i”)一样吗？ 9.如何将字符串反转？ 10.String 类的常用方法都有那些？ 11.抽象类必须要有抽象方法吗？ 12.普通类和抽象类有哪些区别？ 13.抽象类能使用final 修饰吗？

14.接口和抽象类有什么区别？ 15.java 中IO 流分为几种？ 16.BIO、NIO、AIO 有什么区别？ 17.Files的常用方法都有哪些？ 二、容器 18.java 容器都有哪些？ 19.Collection 和Collections 有什么区别？ 20.List、Set、Map 之间的区别是什么？ 21.HashMap 和Hashtable 有什么区别？ 22.如何决定使用HashMap 还是TreeMap？ 23.说一下HashMap 的实现原理？ 24.说一下HashSet 的实现原理？ 25.ArrayList 和LinkedList 的区别是什么？ 26.如何实现数组和List 之间的转换？ 27.ArrayList 和Vector 的区别是什么？ 28.Array 和ArrayList 有何区别？ 29.在Queue 中poll()和remove()有什么区别？ 30.哪些集合类是线程安全的？ 31.迭代器Iterator 是什么？ 32.Iterator 怎么使用？有什么特点？ 33.Iterator 和ListIterator 有什么区别？ 34.怎么确保一个集合不能被修改？

关于JAVA内部类的说明与使用

关于JAVA内部类的说明与使用 1.关于内部类的说明 1）在一个类中定义另外一个类，这个类就叫做内部类(inner class) 。内部类的定义和普通类的定义没什么区别，它可以直接访问和引用它的外部类的所有变量和方法（包括private），就像外部类中的其他非static成员的功能一样。区别是，外部类只能声明为public和default，而内部类可以声明为private 和protected。 2）当我们建立一个inner class时，其对象就拥有了与外部类对象之间的一种关系，这是通过一个特殊的this reference形成的，当内部类的成员方法中访问某个变量/方法时，如果在该方法和内部类中都没有定义过这个变量，调用就会被传递给内部类中保存的那个外部类对象的引用（OuterClass.this），通过那个外部类对象的引用去调用这个变量。 2．内部类变量访问 2.1在main中直接从外部类调用内部类的方法 class Outer { private int index = 100; class Inner { private int index = 50; void print() { int index = 30; System.out.println(index); // 30 System.out.println(this.index); // 50 System.out.println(Outer.this.index); // 100 } } void print() { Inner inner = new Inner();//得到内部类的引用 inner.print(); } } class Test { public static void main(String[] args) {

java中常用关键字总结

Java中的关键字总结 final 关键字 1、用final修饰的类不能被继承，没有子类； 2、用final修饰的方法，方法不能被重写； 3、用final修饰变量，变量的值不能被修改，表示常量，(书写规范：全部字母都要大写；多个单词，可以使用下划线（_）分开；) 注意：如果被final修饰的变量是一个引用类型的数据，那么通过这个引用改变堆空间中的数据，不会报错；如果被final修饰的变量是一个引用类型的数据，那么通过这个引用改变堆空间中的数据，不会报错； 4、final用于成员变量表示该成员变量为常量，不能被修改，必须在变量定义时赋值。 5、final用于局部变量表示该局部变量为常量，不能被修改，可以在变量定义时赋值，也可以先定义变量后赋值。 什么时候用final关键字? 有的时候不想别人重写我的方法就使用final关键字修饰该方法； static关键字 1、static用于成员变量表示该变量只有一份，也就是说静态成员变量属于类而不属于某个具体的类实例对象，所有的类实例对象共享这个静态成员变量；静态函数是不需要对象的，直接可以使用类名来调用； 2、非静态函数可以调用静态函数；静态函数不能调用非静态函数（非静态函数都是通过对象调用的）；静态函数不能使用非静态成员变量，但可以使用静态成员变量； 3、静态函数调用时不需要对象的，所以不能使用和对象有关的关键字；(this；super；) 4、构造函数不能使用static修饰(构造函数是创建对象，开辟空间，给所有成员变量赋默认值之后，有JVM调用进栈，用来给对象的成员变量赋初始值的) static用于类，这里指的是内部类，那么在别的地方就可以通过外部类名来引用这个静态的内部类。 5、static还可以用于类的代码块，叫做静态代码块，静态代码块在类加载的时候就执行完毕，而类只加载一次；是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先

java四种方法事件监听(匿名类,外部类,内部类,自身)

JAVA四种方法实现事件监听 1.外部类实现事件监听： import java.awt.*; import java.awt.event.*; import javax.swing.*; publicclass Listener1extends JFrame { JButton button1,button2; JPanel pane1,pane2,p1,p2; CardLayout card1=new CardLayout(); /*CardLayout布局方式将容器中的每个组件看作一张卡片。 一次只能看到一张卡片，容器则充当卡片的堆栈*/ Listener1(){ this.setTitle("外部类实现事件监听"); this.setBounds(200,200,300,200); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setVisible(true); init(); } publicvoid init(){ p1=new JPanel(); p1.add(new JLabel("第一个面板")); p1.setBackground(Color.red); p2=new JPanel(); p2.add(new JLabel("第二个面板")); p2.setBackground(Color.green); pane1=new JPanel(card1); pane1.add("红色", p1); pane1.add("绿色", p2); button1=new JButton("红色"); button2=new JButton("绿色"); pane2=new JPanel(); pane2.add(button1); pane2.add(button2); this.add(pane1,BorderLayout.CENTER); this.add(pane2,BorderLayout.SOUTH); button1.addActionListener(new ColorEvent(card1,pane1));

JAVA中常用类的常用方法

JAVA中常用类的常用方法 一、https://www.360docs.net/doc/f411433911.html,ng.Object类 1、clone()方法 创建并返回此对象的一个副本。要进行“克隆”的对象所属的类必须实现https://www.360docs.net/doc/f411433911.html,ng. Cloneable接口。 2、equals(Object obj)方法 ?功能：比较引用类型数据的等价性。 ?等价标准：引用类型比较引用，基本类型比较值。 ?存在特例：对、Date及封装类等类型来说，是比较类型及对象的内容而不考虑引用的是否为同一实例。 3、finalize()方法 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。 4、hashCode()方法返回该对象的哈希码值。 5、notify()方法唤醒在此对象监视器上等待的单个线程。 6、notifyAll()方法唤醒在此对象监视器上等待的所有线程。 7、toString()方法 返回该对象的字符串表示。在进行String与其它类型数据的连接操作时，自动调用toString()方法。可以根据需要重写toString()方法。 8、wait()方法 在其他线程调用此对象的notify() 方法或notifyAll() 方法前，导致当前线程等待。 二、字符串相关类 l String类 charAt(int index) 返回指定索引处的char 值。 compareTo(String anotherString) 按字典顺序比较两个字符串。 compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。 concat(String str) 将指定字符串连接到此字符串的结尾。 endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 equals(Object anObject) 将此字符串与指定的对象比较。 equalsIgnoreCase(String anotherString) 将此String 与另一个String 比较，不考虑大小写。indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 indexOf(String str) 返回第一次出现的指定子字符串在此字符串中的索引。 lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 length() 返回此字符串的长度。 replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用newChar 替换此字符串中出现的所有oldChar 得到的。split(String regex) 根据给定正则表达式的匹配拆分此字符串。 startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。 substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的beginIndex 处开

Java中局部内部类可以访问它所在方法中定义的final修饰(精)

public class LocalInnerClassTest{ public static void main(String[] args{ Outer obj=new Outer(; //生成一个外部类对象 SuperInner si=obj.outer(; //调用外部类中的outer(方法，返回一个SuperInner类型对象赋值给si si.m1(; //调用被覆盖的方法m1(,输出：Inner's m1( 20 } } /** *定义一个接口SuperInner，内部定义一个抽象方法m1(,无返回类型 */ interface SuperInner{ public void m1(; } /** *定义一个类Outer，内部只定义一个方法outer(，返回类型为SuperInner */ class Outer{ public SuperInner outer({ int a=10; //方法中定义一个局部变量a，并赋值为10 final int b=20; //再定义一个final局部变量b，初始化为20 class Inner implements SuperInner{ //在outer(方法中定义一个局部内部类Inner,实现接口SuperInner public void m1({ //类中只有一个覆盖接口SuperInner的方法m1(

System.out.println("Inner's m1("+a; //编译报错 System.out.println("Inner's m1( "+b; //编译通过，输出：Inner's m1( 20 } } return new Inner(; } } 我们先从主方法开始看代码的执行顺序，先生成一个Outer类对象obj，obj调用本类中方法outer(；程序开始跳到outer(方法内执行程序语句，先后生成局部变量a和b,再定义一个局部内部类Inner，返回一个SuperInner类型的对象。将返回的SuperInner类型对象地址传给SuperInner类型对象si。si再调用m1(方法，因为已经在局部内部类中覆盖了接口中的m1(方法，所以将调用局部内部类中的m1(方法，程序跳到局部内部类中m1(方法内执行程序语句，先输出一段字符串和a，结果编译报错，先将这条程序语句隐藏，执行下面的语句，你会发现编译通过而且输出Inner's m1( 20！ 为什么会这样呢？大家都知道局部变量仅仅在一个范围内有效，在方法调用完就被内存释放，在Outer类对象obj调用outer(方法时，a和b才产生，调用结束后被内存释放，那么b这个值也就不复存在了，为什么还会输出20呢？难道局部变量被final修饰就不会被内存释放而保留？ 其实有部分操作对于程序员是透明的，那是JAVA语言开发者的小把戏，在定义a和b 时 JVM(JAVA虚拟机做了程序员看不到的操作，他将b拷贝了一份给局部内部类，也就是说JVM在局部内部类中定义了一个final int b=20；这个操作程序员是不知道的！当调用m1(方法时输出的20并不是原来outer(方法中定义的b，而仅仅是JVM拷贝的一个副本。那么为什么a没被打印出呢？那是因为JVM并没有拷贝它，因为没有final修饰，说明它可以被修改，如果把a 改为a++，此时JVM就不知道拷贝a还是a++了，所以对于无final修饰的局部变量JVM是不会拷贝传给局部内部类的，自然无法打输出！

实验5Java常用类(一)

实验5 Java类库和常用类（一） 一. 实验目的及实验环境 1理解类库的概念，掌握分析、应用类库中的类的方法。 2熟练掌握Math类的常用方法。熟悉Random类的常用方法。 3理解String类的特性，熟练掌握String类的常用方法。 4能用Date类创建对象，熟练掌握Date类的常用方法。 5熟练掌握SimpleDateFormat解析日期和设置日期输出格式。 6学会查阅Java API在线参考文档和离线文档的方法。 二. 实验内容 1 基本内容（实验前请及时熟悉如下相关内容） 1）练习使用Math类的常用方法。 2）应用String类编程练习。 3）编写程序应用Random类生成随机数。 4）练习使用Date类的常用方法。 5）查阅Java API在线参考文档和下载Java API离线文档。 示例1. 应用SimpleDateFormat类的程序示例如下,共同学们模仿参考。 import java.text.*; import java.util.Date; public class FormatDateTime { public static void main(String[] args) { SimpleDateFormat myFmt = new SimpleDateFormat("yyyy年MM月dd日 HH 时mm分ss秒"); SimpleDateFormat myFmt1 = new SimpleDateFormat("yy/MM/dd HH:mm"); SimpleDateFormat myFmt2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 等价于now.toLocaleString() SimpleDateFormat myFmt3 = new SimpleDateFormat("yyyy年MM月dd日 HH 时mm分ss秒 E "); SimpleDateFormat myFmt4 = new SimpleDateFormat("一年中的第 D 天一年中第w个星期一月中第W个星期在一天中k时 z时区"); Date now = new Date();//当前时间 System.out.println(myFmt.format(now)); System.out.println(myFmt1.format(now)); System.out.println(myFmt2.format(now)); System.out.println(myFmt3.format(now)); System.out.println(myFmt4.format(now)); System.out.println(now.toGMTString());//The method toGMTString() from the type Date is deprecated. System.out.println(now.toLocaleString()); System.out.println(now.toString()); } }

Java基础_内部类、静态内部类、成员内部类、局部内部类、匿名内部类

Java基础_内部类、静态内部类、成员内部类、局部内部类、匿名内部类内部类： 使用内部类减少了命名冲突。 一个内部类可以定义在一个类中，一个方法中甚至一个表达式中。 内部类分为四种： 静态内部类(static inner classes) 成员内部类(member inner classes) 局部内部类(local inner classes) 匿名内部类(anonymous inner classes) 1、静态内部类(static inner classes) 最简单的内部类。 只能访问外部类的静态成员变量与静态方法。 生成静态内部类对象的方法： OuterClass.InnerClass inner = new OuterClass.InnerClass(); 1.1、相关使用例子： 静态内部类： 1class StaticInner{ 2private static int a = 1; 3 4/** 5* 静态内部类 6* 生成的类名：StaticInner$InnerClass 7*/ 8public static class InnerClass{ 9//静态内部类可以声明静态的成员变量，其他的内部类不可以 10private static int b = 1; 11public void execute(){ 12//静态内部类只能访问静态程序 13System.out.println(a + b); 14} 15} 16 } main方法中使用： 1public static void main(String[] args) { 2//创建静态内部类 3StaticInner.InnerClass innerClass = new StaticInner.InnerClass(); 4innerClass.execute(); 5 } 2、成员内部类(member inner classes)： 成员内部类可以访问外部类的静态与非静态的方法和成员变量。 生成成员内部类对象的方法： OuterClass.InnerClass inner = new OuterClass().new InnerClass(); 在局部内部类中访问外部类的成员变量的方法：

Java 内部类、成员类、局部类、匿名类等

本文由我司收集整编，推荐下载，如有疑问，请与我司联系 Java 内部类、成员类、局部类、匿名类等 2016/10/13 0 Java 各种称呼类详解Java 有各种各样类，内部类、嵌套类、成员类、局部类（本地类）、静态类、匿名类、文件类以及这些组合起来的称呼类，成 员内部类，成员匿名类，成员嵌套类，本地匿名类等，真是多的不行，但有些其实 是一个意思，在这里好好理一理。 声明 1.注意，这些称呼都是翻译过来的，但是同一个英文单词或一个词组翻译过 来可能有不同叫法，比如local nested class，local 有局部、本地意思，其实是一个意思，local nested class 翻译过来就是局部嵌套类（本地嵌套类），又因为非静态嵌套类都称为内部类，因此local nested class 又叫为内部局部类（本地内部类），最终又简称为：局部类（本地类）。我个人觉得局部类更加形象点因此下面都优先采用局部 类一说。 2.我通过搜索找到两种不太相同的内部类定义，一种认为：定义在类里面 的称为嵌套类(nested class)，而非静态嵌套类才是内部类(inner class)，也就是说嵌套类包含内部类；另外一种则是认为：定义在类里面的称为内部类，这样静态嵌套类 也是内部类，也就是说嵌套类=内部类。但是，第一种才是Java 语言规范规定的， 我一开始不确定，找到Java7 的语言规范验证，结果确实如此，即第一种才是正确 的，那么问题来了：依照第一种划分，静态内部类其实是一种错误说法。。。只有静 态嵌套类，内部类是没有静态一说的！但是对于大多数中国程序员，貌将定义在 类里面的类称为内部类不是更符合文意么？也许这就是为什么会有这么多人一直认 为静态内部类的存在。嘛，反正不管怎么称呼，只要知道代表什么意思就好，细节 什么的不要在意（光哥：因此不注意细节的你写的代码才这么一大堆bug 么？还不 赶紧去改（怒））。我这里采用Java 语言规范上说的。 0.文件类文件类放在最前面，是因为文件类是与主类（一个文件中public 类）关 系最不密切的一类。什么是文件类？看代码就知道： code >class Test{} span > span > span >【注意】：主类这一定义是我自己按语义称呼的，有的地方称为基本类，但我觉得很不符合语义，Java 语言规范我也没找到相 关定义。

java常用类知识点总结

java常用类知识点总结 Java常用类 要求: 1、掌握String和StringBuffer的区别，可以熟练使用String和StringBuffer的各 种方法进行相关操作。 2、能够自己编写一个得到日期的操作类，并将日期进行格式化操作。 3、掌握比较器及其基本原理，并可以通过比较器进行对象数组的比较操作。 4、掌握对象克隆技术及其实现 5、能够灵活应用正则表达式对字符串的组成进行判断 6、掌握Math、Random、基本数据类型的包装类的使用 7、描述出Object System对垃圾收集的支持 8、使用NumberFormat、DecimalFormat、BigInteger、BigDecimal进行数字的操 作 String和StringBuffer String的内容一旦声明不可改变，如果要改变，改变的是String的引用地址，如果一个字符串要经常改变，必须使用StringBuffer。 在一个字符串内容需要频繁修改时，使用StringBuffer可以提升操作性能，因为StringBuffer内容可以改变，而String内容不可改变。StringBuffer支持的方法大部分与String类似。 StringBuffer常见用法: (1) 字符串的连接操作

String类可以通过“+“进行字符串的连接，而StringBuffer中却只能使用append方法进行字符串的连接，而且此方法返回一个StringBuffer类的实例，这样就可以采用代码链的形式一直调用append方法。 (2) 在任意位置处为StringBuffer添加内容 可以使用insert方法在指定位置上为StringBuffer添加内容 字符串的反转操作(较为常见的操作，使用reverse方法) (3) 替换指定范围的内容 replace方法可对指定范围的内容进行替换。在String中如果要替换，使用的是replaceAll (4) 字符串截取(使用subString方法从指定范围中截取内容) (5) 删除指定范围的字符串(使用delete方法删除指定范围内容) (6) 查找指定内容是否存在(indexOf查找指定内容，查找到返回内容的位置， 没查到返回-1) 问题:(1)String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有, 没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢,答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改， 或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符

03-9_内部类_5题

内部类 知识点总结： 1内部类可以分为四种：静态内部类、成员内部类、局部内部类以及匿名内部类。 2非静态内部类被访问的唯一方式是在运行时刻有一个外部类的对象，然后才能创建内部类对象。不可能用外部类的静态方法来创建非静态内部类的对象。 3在碰到匿名内部类的题目时一定要注意最后的大括号后面还要有一个分号。

Question90 Given the exhibit: 10.class Line{ 11.public static class Point{} 12.} 13. 14.class Triangle{ 15.//insert code here 16.} Which code,inserted at line15,creates an instance of the Point class defined in Line? A.Point p=new Point(); B.Line.Point p=new Line.Point(); C.The Point class cannot be instatiated at line15. D.Line l=new Line();l.Point p=new l.Point(); 本题考点： 静态内部类 考点说明： 静态内部类类似一个静态的方法，在调用时可以使用本类的类名“.”要调用的静态内部类来生成对象。 本题详解： 本题中在Line这个类中Point类属于静态内部类，所以在其他类中不能被直接创建对象。而C选项是说Point类不能在15行被生成。静态内部类的对象可以直接生成：Outer.Inner in=new Outer.Inner()；而不需要通过生成外部类对象来生成，这样实际上使静态内部类成为了一个顶级类，并且静态内部类不可用private来进行定义，所以D选项也不对。只有B选项是正确的。 Answer:B