资料评价：
所需积分：5君，已阅读到文档的结尾了呢~~
java基础知识思考题,java基础知识,java基础知识总结,java基础知识点,小学二年级思考题,小学数学思考题,java编程基础知识,思考题,小学一年级思考题,有关内存的思考题,五年级数学思考题
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
java基础知识思考题
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='/DocinViewer-4.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口怎样学习J API太多了而且是中文的。是不是学好JAVA就要多学API 中的东西？
全部答案（共3个回答）
ng.*
java.util.*
t.*;
javax.swing.*
最常用的几个包掌握好了，基本上就掌握了API的精华
我是这样学过来的,先学dephi 然后c++ 现在java ,确实有很多好处.
java本身就很容易.有了c++的基础能帮助你了解很多java封装的东西.
对日外包业务也有很多不同的业务领域和形态。例如有全生命周期的外包（类似于集成项目开发），也有只实施编码与单元测试等方式。开发语言就更多了，仅仅我们公司就有C++...
在学习Java的过程中主要围绕以下几个方面来学习：
1．时刻提醒自己Java是一种OOP语言工具，而不仅仅是编码，只有这样才能总体把握和运用JAVA。
2．在...
先看C++,C++方面的书籍潭浩强的比较适合入门,C++是学一切语言的基础.
接下来就看《Java核心技术 I》和《Java核心技术 II》这两本是入门J...
Java是一种纯面向对象的编程语言，要学好Java必须对面向对象思想有深刻的理解。Java分3个版本JavaSE、JavaME、JavaEE分别用于跨平...
谁住过梅斯蒂亚Guesthouse Rustaveli Str. 7,是否推荐？
答: 这个要设计到JNI的开发,就是用Java来调用C语言的函数库,还要编写缓冲器来解决传输问题,还有就是网络协议一定要了解,做的时候要用多线程来控制你所有的缓冲器,...
答: 所谓的网络编程，不论c还是java，本质上都是通过socket进行数据传输；
一般情况下可以使用的传输协议有tcp、udp、ftp等等，这些协议为网络变成提供...
大家还关注
确定举报此问题
举报原因(必选)：
广告或垃圾信息
激进时政或意识形态话题
不雅词句或人身攻击
侵犯他人隐私
其它违法和不良信息
报告，这不是个问题
报告原因(必选)：
这不是个问题
这个问题分类似乎错了
这个不是我熟悉的地区Java 面试题基础知识集锦
作者：deepinmind
字体：[ ] 类型：转载 时间：
本文主要介绍Java基础面试题集锦，这里整理了面试java工程师的基础知识题锦，有需要的小伙伴可以参考下
经典的Java基础面试题集锦，欢迎收藏和分享。
问题：如果main方法被声明为private会怎样？
答案：能正常编译，但运行的时候会提示”main方法不是public的”。
问题：Java里的传引用和传值的区别是什么？
答案：传引用是指传递的是地址而不是值本身，传值则是传递值的一份拷贝。
问题：如果要重写一个对象的equals方法，还要考虑什么？
答案：hashCode。
问题：Java的”一次编写，处处运行”是如何实现的？
答案：Java程序会被编译成字节码组成的class文件，这些字节码可以运行在任何平台，因此Java是平台独立的。
问题：说明一下public static void main(String args[])这段声明里每个关键字的作用
答案：public: main方法是Java程序运行时调用的第一个方法，因此它必须对Java环境可见。所以可见性设置为pulic.
static: Java平台调用这个方法时不会创建这个类的一个实例，因此这个方法必须声明为static。
void: main方法没有返回值。
String是命令行传进参数的类型，args是指命令行传进的字符串数组。
问题：==与equals的区别
答案：==比较两个对象在内存里是不是同一个对象，就是说在内存里的存储位置一致。两个String对象存储的值是一样的，但有可能在内存里存储在不同的地方 .
==比较的是引用而equals方法比较的是内容。public boolean equals(Object obj) 这个方法是由Object对象提供的，可以由子类进行重写。默认的实现只有当对象和自身进行比较时才会返回true,这个时候和==是等价的。String, BitSet, Date, 和File都对equals方法进行了重写，对两个String对象 而言，值相等意味着它们包含同样的字符序列。对于基本类型的包装类来说，值相等意味着对应的基本类型的值一样。
public class EqualsTest {
public static void main(String[] args) {
String s1 = “abc”;
String s2 = s1;
String s5 = “abc”;
String s3 = new String(”abc”);
String s4 = new String(”abc”);
System.out.println(”== comparison : ” + (s1 == s5));
System.out.println(”== comparison : ” + (s1 == s2));
System.out.println(”Using equals method : ” + s1.equals(s2));
System.out.println(”== comparison : ” + s3 == s4);
System.out.println(”Using equals method : ” + s3.equals(s4));
== comparison : true
== comparison : true
Using equals method : true
Using equals method :true
问题：如果去掉了main方法的static修饰符会怎样？
答案：程序能正常编译。运行时会抛NoSuchMethodError异常。
问题：为什么oracle type4驱动被称作瘦驱动？
答案：oracle提供了一个type 4 JDBC驱动，被称为瘦驱动。这个驱动包含了一个oracle自己完全用Java实现的一个TCP/IP的Net8的实现，因此它是平台独立的，可以在运行时由浏览器下载，不依赖任何客户端 的oracle实现。客户端连接字符串用的是TCP/IP的地址端口，而不是数据库名的tnsname。
问题：介绍一下finalize方法
答案： final: 常量声明。 finally: 处理异常。 finalize: 帮助进行垃圾回收。
接口里声明的变量默认是final的。final类无法继承，也就是没有子类。这么做是出于基础类型的安全考虑，比如String和Integer。这样也使得编译器进行一些优化，更容易保证线程的安全性。final方法无法重写。final变量的值不能改变。finalize()方法在一个对象被销毁和回收前会被调用。finally,通常用于异常处理，不管有没有异常被抛出都会执行到。比如，关闭连接通常放到finally块中完成。
问题：什么是Java API？
答案：Java API是大量软件组件的集合，它们提供了大量有用的功能，比如GUI组件。
问题：GregorianCalendar类是什么东西？
答案：GregorianCalendar提供了西方传统日历的支持。
问题：ResourceBundle类是什么?
答案：ResourceBundle用来存储指定语言环境的资源，应用程序可以根据运行时的语言环境来加载这些资源，从而提供不同语言的展示。
问题：为什么Java里没有全局变量?
答案：全局变量是全局可见的，Java不支持全局可见的变量，因为：全局变量破坏了引用透明性原则。全局变量导致了命名空间的冲突。
问题：如何将String类型转化成Number类型？
答案：Integer类的valueOf方法可以将String转成Number。下面是代码示例：
String numString = “1000″;
int id=Integer.valueOf(numString).intValue();
问题：SimpleTimeZone类是什么?
答案：SimpleTimeZone提供公历日期支持。
问题：while循环和do循环有什么不同？
答案：while结构在循环的开始判断下一个迭代是否应该继续。do/while结构在循环的结尾来判断是否将继续下一轮迭代。do结构至少会执行一次循环体。
问题：Locale类是什么？
答案：Locale类用来根据语言环境来动态调整程序的输出。
问题：面向对象编程的原则是什么?
答案：主要有三点，多态，继承和封装。
问题：介绍下继承的原则
答案：继承使得一个对象可以获取另一个对象的属性。使用继承可以让已经测试完备的功能得以复用，并且可以一次修改，所有继承的地方都同时生效。
问题：什么是隐式的类型转化?
答案：隐式的类型转化就是简单的一个类型赋值给另一个类型，没有显式的告诉编译器发生了转化。并不是所有的类型都支持隐式的类型转化。
代码示例：
int i = 1000;
long j = //Implicit casting
问题：sizeof是Java的关键字吗?
答案：不是。
问题：native方法是什么?
答案：native方法是非Java代码实现的方法。
问题：在System.out.println()里面,System, out, println分别是什么?
答案：System是系统提供的预定义的final类，out是一个PrintStream对象，println是out对象里面一个重载的方法。
问题：封装，继承和多态是什么？
答案：简单来说，多态是指一个名字多种实现。多态使得一个实体通过一个通用的方式来实现不同的操作。具体的操作是由实际的实现来决定的。
多态在Java里有三种表现方式：方法重载通过继承实现方法重写通过Java接口进行方法重写。
问题：显式的类型转化是什么?
答案：显式的类型转化是明确告诉了编译器来进行对象的转化。
代码示例：
long i = 700.20;
int j = (int) //Explicit casting
问题：什么是Java虚拟机?
答案：Java虚拟机是能移植到不同硬件平台上的软件系统。
问题：类型向下转换是什么?
答案：向下转换是指由一个通用类型转换成一个具体的类型，在继承结构上向下进行。
问题：Java的访问修饰符是什么?
答案：访问权限修饰符是表明类成员的访问权限类型的关键字。使用这些关键字来限定程序的方法或者变量的访问权限。它们包含：
public: 所有类都可以访问 protected: 同一个包内以及所有子类都可以访问 private: 只有归属的类才能访问默认: 归属类及相同包下的子类可以访问
问题：所有类的父类是什么？
答案：Object.
问题：Java的基本类型有哪些?
答案：byte,char, short, int, long, float, double, boolean。
问题：静态类型有什么特点?
答案：静态变量是和类绑定到一起的，而不是类的实例对象。每一个实例对象都共享同样一份静态变量。也就是说，一个类的静态变量只有一份，不管它有多少个对象。类变量或者说静态变量是通过static这个关键字来声明的。类变量通常被用作常量。静态变量通常通过类名字来进行访问。当程序运行的时候这个变量就会创建直到程序结束后才会被销毁。类变量的作用域和实例变量是一样的。它的初始值和成员变量也是一样的，当变量没被初始化的时候根据它的数据类型，会有一个默认值。类似的，静态方法是属于类的方法，而不是类对象，它的调用并不作用于类对象，也不需要创建任何的类实例。静态方法本身就是final的，因为重写只会发生在类实例上，静态方法是和类绑定在一起的，不是对象。父类的静态方法会被子类的静态方法屏蔽，只要原来方法没有声明为final。非静态方法不能重写静态方法，也就是说，你不能在子类中把一个静态方法改成实例方法。
非静态变量在每一个对象实例上都有单独的一份值。
问题：&操作符和&&操作符有什么区别?
答案：当一个&表达式在求值的时候，两个操作数都会被求值，&&更像是一个操作符的快捷方式。当一个&&表达式求值的时候，先计算第一个操作数，如果它返回true才会计算第二个操作数。如果第一个操作数取值为fale,第二个操作数就不会被求值。
问题：Java是如何处理整型的溢出和下溢的?
答案：Java根据类型的大小，将计算结果中的对应低阶字节存储到对应的值里面。
问题：public static void写成static public void会怎样？
答案：程序正常编译及运行。
问题，声明变量和定义变量有什么不同？
答案：声明变量我们只提供变量的类型和名字，并没有进行初始化。定义包括声明和初始化两个阶段S只是变量声明，String s = new String(“bob”); 或者String s = “bob”;是变量定义。
问题：Java支持哪种参数传递类型?
答案：Java参数都是进行传值。对于对象而言，传递的值是对象的引用，也就是说原始引用和参数引用的那个拷贝，都是指向同一个对象。
问题：对象封装的原则是什么?
答案：封装是将数据及操作数据的代码绑定到一个独立的单元。这样保障了数据的安全，防止外部代码的错误使用。对象允许程序和数据进行封装，以减少潜在的干涉。对封装的另一个理解是作为数据及代码的保护层，防止保护层外代码的随意访问。
问题：你怎么理解变量？
答案：变量是一块命名的内存区域，以便程序进行访问。变量用来存储数据，随着程序的执行，存储的数据也可能跟着改变。
问题：数值提升是什么?
答案：数值提升是指数据从一个较小的数据类型转换成为一个更大的数据类型，以便进行整型或者浮点型运算。在数值提升的过程中，byte,char,short值会被转化成int类型。需要的时候int类型也可能被提升成long。long和float则有可能会被转换成double类型。
问题：Java的类型转化是什么?
答案：从一个数据类型转换成另一个数据类型叫做类型转换。Java有两种类型转换的方式，一个是显式的类型转换，一个是隐式的。
问题：main方法的参数里面，字符串数组的第一个参数是什么?
答案：数组是空的，没有任何元素。不像C或者C++，第一个元素默认是程序名。如果命令行没有提供任何参数的话，main方法中的String数组为空,但不是null。
问题：怎么判断数组是null还是为空?
答案：输出array.length的值，如果是0,说明数组为空。如果是null的话，会抛出空指针异常。
问题：程序中可以允许多个类同时拥有都有main方法吗?
答案：可以。当程序运行的时候，我们会指定运行的类名。JVM只会在你指定的类中查找main方法。因此多个类拥有main方法并不存在命名冲突的问题。
问题：静态变量在什么时候加载？编译期还是运行期？静态代码块加载的时机呢？
答案：当类加载器将类加载到JVM中的时候就会创建静态变量，这跟对象是否创建无关。静态变量加载的时候就会分配内存空间。静态代码块的代码只会在类第一次初始化的时候执行一次。一个类可以有多个静态代码块，它并不是类的成员，也没有返回值，并且不能直接调用。静态代码块不能包含this或者super,它们通常被用初始化静态变量。
问题：一个类能拥有多个main方法吗？
答案：可以，但只能有一个main方法拥有以下签名：
public static void main(String[] args) {}
否则程序将无法通过编译。编译器会警告你main方法已经存在。
问题：简单的介绍下JVM是如何工作的?
答案：JVM是一台抽象的计算机，就像真实的计算机那样，它们会先将.java文件编译成.class文件（.class文件就是字节码文件）,然后用它的解释器来加载字节码。
问题：如果原地交换两个变量的值？
答案：先把两个值相加赋值给第一个变量，然后用得到的结果减去第二个变量，赋值给第二个变量。再用第一个变量减去第二个变量，同时赋值给第一个变量。代码如下：
int a=5,b=10;a=a+b; b=a-b; a=a-b;
使用异或操作也可以交换。第一个方法还可能会引起溢出。异或的方法如下： int a=5,b=10;a=a+b; b=a-b; a=a-b;
int a = 5; int b = 10;
问题：什么是数据的封装?
答案：数据封装的一种方式是在类中创建set和get方法来访问对象的数据变量。一般来说变量是private的，而get和set方法是public的。封装还可以用来在存储数据时进行数据验证，或者对数据进行计算，或者用作自省（比如在struts中使用javabean）。把数据和功能封装到一个独立的结构中称为数据封装。封装其实就是把数据和关联的操作方法封装到一个独立的单元中，这样使用关联的这些方法才能对数据进行访问操作。封装提供的是数据安全性,它其实就是一种隐藏数据的方式。
问题：什么是反射API？它是如何实现的？
答案：反射是指在运行时能查看一个类的状态及特征，并能进行动态管理的功能。这些功能是通过一些内建类的反射API提供的，比如Class,Method,Field, Constructors等。使用的例子：使用Java反射API的getName方法可以获取到类名。
问题：JVM自身会维护缓存吗，是不是在堆中进行对象分配，操作系统的堆还是JVM自己管理的堆？为什么？
答案：是的，JVM自身会管理缓存，它在堆中创建对象，然后在栈中引用这些对象。
问题：虚拟内存是什么?
答案：虚拟内存又叫延伸内存，实际上并不存在真实的物理内存。
问题：方法可以同时即是static又是synchronized的吗?
答案：可以。如果这样做的话，JVM会获取和这个对象关联的java.lang.Class实例上的锁。这样做等于：
synchronized(XYZ.class) {
问题：String和StringTokenizer的区别是什么？
答案：StringTokenizer是一个用来分割字符串的工具类。
StringTokenizer st = new StringTokenizer(”Hello World”);
while (st.hasMoreTokens()) {
System.out.println(st.nextToken());
问题：transient变量有什么特点?
答案：transient变量不会进行序列化。例如一个实现Serializable接口的类在序列化到ObjectStream的时候，transient类型的变量不会被写入流中，同时，反序列化回来的时候，对应变量的值为null。
问题：哪些容器使用Border布局作为它们的默认布局?
答案：Window, Frame, Dialog。
问题：怎么理解什么是同步?
答案：同步用来控制共享资源在多个线程间的访问，以保证同一时间内只有一个线程能访问到这个资源。在非同步保护的多线程程序里面，一个线程正在修改一个共享变量的时候，可能有另一个线程也在使用或者更新它的值。同步避免了脏数据的产生。
对方法进行同步：
public synchronized void Method1 () {
// Appropriate method-related code.
在方法内部对代码块进行同步：
public myFunction (){
synchronized (this) {
// Synchronized code here.
以上就是对Java 面试题的资料整理，后续继续补充相关资料，谢谢大家对本站的支持！
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具当前位置： >>
Java 基础知识总结
目录CoreJava DAY01 Java 概述 ............................................................................................................. 1 CoreJava DAY02 数据类型和控制结构..................
....................................................................... 6 CoreJava DAY03 数组 .................................................................................................................. 11 CoreJava DAY04 ............................................................................................................................ 15 CoreJava DAY05 面向对象........................................................................................................... 17 CoreJava DAY06 类的加载过程、实例化、继承、多态 ........................................................... 20 CoreJava DAY07 修饰符 ............................................................................................................... 26 CoreJava DAY08 常用类 .............................................................................................................. 29 CoreJava DAY09 高级语言特征................................................................................................... 30 CoreJava DAY10 主方法，静态导入，包装类，枚举 ............................................................... 32 CoreJava DAY11 内部类............................................................................................................... 36 CoreJava DAY12 集合 List .......................................................................................................... 40 CoreJava DAY13 集合 Set ........................................................................................................... 45 CoreJava DAY14 集合 Map ......................................................................................................... 48 CoreJava DAY15 异常、断言....................................................................................................... 51 CoreJava DAY16 反射、注释....................................................................................................... 56 CoreJava DAY17 GUI .................................................................................................................... 63 CoreJava DAY18 awt event ............................................................................................................ 80 CoreJava DAY19-20 多线程 ......................................................................................................... 84 CoreJava DAY21-22 IO .................................................................................................................. 94 CoreJava DAY23 网络编程......................................................................................................... 1061CoreJava DAY01 Java 概述############################################################################### ########## CoreJava DAY01() ############ ########## Made by NieXu ############ ############################################################################### 一、学习 CoreJava 的要求 1、上课一定要听懂（理解） 2、课后一定要练习 3、练完后要思考 二、Java 的优势 1、Java 中省去了对指标的操作，但并不是没有指标了，只是被封装了而已，代替指标的 是种新的变量，叫做引用，这个引用里面也是保存的一个对象的地址，它和指针的差别就是 比指针功能要弱化了，也更简单了。 2、安全性好，字节码的验证 3、Java 的跨平台性：用这个语言开发出来的程序可以在不同系统中运行： 源码是怎样成为可执行代码的 源码--&编译--&目标码（二进制机器码）--&连接--&可执行档 由此看来，汇编、C、C++等语言都是不跨平台的，因为他们的编译过程就直接与当前 系统挂钩了，C 和 C++源码都是跨平台的，我们所指的跨平台是基于编译过程中的跨平台， 以上几种语言在不同的系统中编译出来的目标码是不同的。 Java 跨平台就是编译过程中的跨平台，怎么实现的呢，那就是 Java 虚拟机： Java 的源码编译过程： 源码--&编译--&字节码--&把字节码装载到虚拟机中运行 --JAVA 虚拟机：JVM 屏蔽掉了不同平台的差异，为上层的字节码提供了一个统一的运行环境 虚拟机是为了给字节码提供统一的执行平台， 每种操作系统所用的虚拟机是不同的， 是 为了统一 JAVA 字节码的解析执行方式，如果没有虚拟机，在一种操作系统上写了 JAVA 代 码， 编译成字节码后只能在本操作系统上运行， 但是换一个操作系统的话就要重新再写一遍 JAVA 代码然后重新编译， 所以虚拟机提高了代码的复用性，实现了一次编写，多处使用的优点。 不同系统的 Java 虚拟机之前的源码和字节码部分都是跨平台的，从虚拟机就不是跨平 台的了。 这样 Java 的字节码就可以直接用来传播，而不用传播源码了。 三、对 Java 课程总体的大纲的介绍 四、JDK/JRE/JVM JDK：JAVA 开发工具包，比 JRE 多了一些开发和调试的命令，比如 javac、java 等等。 JRE：JAVA 运行环境 JVM：JAVA 虚拟机 包含关系：JDK 包含 JRE，JRE 包含 JVM 如果你搭建的 Java 开发环境是用来做 Java 开发的，那么就安一个 JDK 如果你不做开发，而只是运行别人开发调试好的程序，那么就只安装一个 JRE 就可以了 一般服务器上就只安装 JRE1针对不同的操作系统有不同的 JDK 下载 在 JDK 安装好后的档夹中有个 bin 目录， 里面一般是我们经常用到的一些命令， 比如 javac、 java 在 JDK 目录下有个 src.zip n，解压开后就是 JDK 类库中的源码，也就是 rt.jar 压缩n中 class n的源码。 jre 目录是 JDK 自带的 JRE，里面也有 bin 目录，一般存放的是运行时的一些命令 jre 活页夹中的 lib 文件中有一些 jar 文件，里面都是一些 class n在虚拟机运行时作为类 代码其中一个比较重要的 jar n就是 rt.jar，里面放的是 JDK 给我们提供的一整套类库的字 节码。 五、配置环境变量 JAVA_HOME：JDK 的安装路径 CLASSPATH：类的搜索路径 PATH：命令的搜索路径 Linux： --一般 JDK 是放在/opt/jdk1.6.0_05 --配置环境变量的文件是主目录中的&.bash_profile&文件 进入终端后：vi .bash_profile 在里面配置： JAVA_HOME=/opt/jdk1.6.0_05 CLASSPATH=. PATH=$PATH:$JAVA_HOME/bin:....... export JAVA_HOME export CLASSPATH export PATH --配置完后保存退出，然后 source .bash_profile 在命令行打 java 命令验证是否配置成功，如果成功了，注销一遍系统 Windows: --右键我的计算机--&高级--&环境变量--&在系统变量或者用户变量上配置--& JAVA_HOME：当前机器上 JDK 的文件目录 &C:\Program Files\Java\jdk1.6.0_05& CLASSPATH：类的搜索路径 &.&当前目录 Path:命令的搜索路径 ...;%JAVA_HOME%\bin --开始--&运行--&cmd--&java 验证是否配置成功 六、第一个 JAVA 程序 一个 java n只能定义一个 public 类，并且 public 修饰的类的类名要与文件名相同 vi MyFirstJava.java public class MyFirstJava{ public static void main(String[] args){ String name=&tangliang&; int age=30; System.out.println(&my name is:&+name); System.out.println(&my age is:&+age);2} } 写好后在命令行 cd 到文件所在目录，然后打 javac MyFirstJava.java 编译n 编译成功后当前n夹中会出现一个 MyFirstJava.class 文件 运行：java MyFirstJava 结果： my name is:tangliang my age is：30 要学会编译出错后查找错误！ 在n中在定义一个 class Animal{} 保存编译后档中就会多一个 Animal.class n，也就是说，n中有多少类，那么就有多少 类n java 命令执行所做的东西 1、找到类的字节码文件，要用到 CLASSPATH 的环境变量 2、加载类到内存中 3、找类的主方法，main 方法，执行代码 七、包 1、作用，java 程序很庞大的话会有很多类n，问了分类存放，那么就把相同类型的类n 放在同一个包中。 2、语法： package 包名; ...正文; 编译时用 javac -d 目录 XX.java 编译好后，class n会被自动放在自己定义的包（自动生成的n夹）中，包会放在编译 命令中指定的目录中执行时在包所在的当前目录下打 java 包名.类名 八、注释 三种： 1、单行注释: //... 2、多行注释: /*...*/ 3、文n注释: /**......*/ 另一种多行注释，但是这种注释可以生成 API 文n（HTML 格 式的） 提取 API 文n的命令：javadoc javadoc 应用，提取说明文件 javadoc XX.java -d 生成文文件路径 比如：javadoc String.java -d .\stringdoc 在 String.java 所在的n夹中便会生成一个 stringdoc n夹，里面是 html 格式的解释 文n 顺便教下学生看 API 文n 九、import 如果在一个 java n中用到了不在同一个包中的类的话，就要用 import 来引入一个类 语法：import 包名.类名 写在 package 后，类定义前 引入一个类3注意： package 在 java n中只能出现一次，并在最前面 import 可以有多条 写在 package 后，类前 十、创建 jar 文件命令 把指定的包中的 class n打包成 jar n 语法： jar cvf jar 文件名 要打包的n夹 比如：jar cvf abc.jar ./day01 执行完后在当前目录会生成一个 abc.jar 的n， 解压后就是 day01 n夹， 里面还是 class n cvf:create view filename 创建可视文件名 如果在别的 java n中要用到此 jar n中的类， 那么就要在环境变量的 CLASSPATH 中多 配一个 abc.jar 的路径。然后在类n中直接 import 这个类就可以了 CLASSPATH 配置完成后， JVM 先从当前路径下找类， 再从 rt.jar 中找类， 然后再从 abc.jar 中找这个类 十一、JDK 中的基础包 java.lang 语言包 java.awt/javax.swing/java.awt.event 图形开发包 java.applet JAVA 的 applet 小程序包 java.io 输入输出流包 java.net 网络包 java.util 工具包第二章 语言元素 一、标识符 只能以字母,D_‖,D$‖符号开头，不能以数位开头 支持汉字 二、良好的编码习惯 1、类的首字母要大写，如果有多个单词，每个单词首字母都要大写 比如：HelloWorld 2、接口名命名与类名一样 3、方法名第一个单词小写，以后每个单词的首字母都大写 比如：getName 4、变量名的命名习惯和方法名的相同 5、常量（不可改变的）的名字所有字母都大写，单词与单词之间用D_‖连接 比如： DRIVER_NAME 6、包名所有字母都小写 三、关键词（50 个） 自己命名变量名或者其它名字不能和关键词的一样 true，false，null 不是关键词，是字面值，同样不能把这些单词作为名字 goto 和 const 是保留字，并不应用于 java 开发，也不能作为其它名字使用 其它语言中 goto 语句的用法（无条件跳转） java 中的代替 goto 的是 loop 是个标号，标记一个循环，break loop 就结束了 这个循环 四、数据类型4八种基本数据类型 boolean 两个值 true 或者 false 8位 byte 8 位整数 short 16 位整数 char 16 位的 Unicode 编码，有足够的空间保存非英文字符 int 32 位整数 long 64 位整数 float 32 位浮点型 double 64 位浮点型引用类型： 类，接口，数组，枚举，标注5CoreJava DAY02 数据类型和控制结构############################################################################## ########## CoreJava DAY02() ############## ########## Made by NieXu ############# ############################################################################### 一、数据类型 boolean 两个值 true 或者 false，占 8 个二进制位 7 中数值类型 byte 8 位整数 short 16 位整数 char 16 位的 Unicode 编码，有足够的空间保存非英文字符 --'A':65,'a':97,'0':48 int 32 位整数 long 64 位整数 float 32 位浮点型 double 64 位浮点型 二、String 类型：是一个类，而不是基本类型 赋值的话就用双引号引起来，比如 String a=&abc&; String 的几种常用方法： charAt(int n);获取这个字符串的 n 位置的字符，n 从 0 开始 concat(String str);把当前字符串与参数中的字符串连接到一起返回一个新字符串 其它的教学生自己去查 三、整型数据 1、整型变数赋值 int ia=0x55;//这种赋值是可以的，赋值为了一个 16 进制资料 byte bb=0x771;//0x771 已经超出了 byte 的取值范围，所以编译这句话会出错 byte ba=(byte)0x771;//把 0x771 强制转换成 byte long la=1234567L;//给 long 类型的变量赋值 2、强转后值如何变化： 规则： 整数在内存空间中的存储方式： byte b=39;b 转换成二进制是
short s=39;b:10 0111 -39 为 39 的补码：个位取反，末位加一
就代表-39 如果最高位是 0，那么就是存的一个正整数，1 就代表负整数 -128 的二进制要先求 128 的原码
求补码后-128 的二进制表现为 11 1111 代表-1 整型数据强转如果大转小的话直接把其二进制高位截掉，保留低位 0x771 换算成二进制 01，强转成 byte 后为
四、浮点型数据61、赋值 float fa=123.4F//后面加个 F double d=123.456D//后面的 D 跟不跟都可以 2、存储方式暂不用理解类型转换： 自动类型转换 小范围---?大范围 Byte -? short -? int -? long -? float -? double Char -? int 在表数范围内的常数可以自动转换 强制类型转换五、对象类型（引用类型） 1、属于所有非基本类型的其它类型 2、类型的分类： --八种基本类型 --引用类型 3、在内存中的存储方式 对象类型的变量实际上存储的是对象所在的内存的地址 一个对象类型占四个字节，也就是其最大寻址空间是 4G。 内存被分为两块空间：栈空间和堆空间 --栈：负责给方法分配空间 main 方法在栈的最下面 方法里对象的引用也是存在栈空间中的 存储对象的引用如果是定义在方法体内的也是存在栈中的 --堆：给对象分配空间 对象就相当于一个气球，引用就相当于栓着气球的绳子 一个对象可以有多个引用指向它。 六、垃圾回收 1、如果某一个对象没有引用指向它了，那么这个对象就是个垃圾对象 比如 String s=new String(&...&); s= 那被 new 出来的 String 对象就是一个垃圾数据了 2、垃圾回收机制 对于没有被引用的对象，java JVM 会自动回收 System.gc() 提醒虚拟机进行垃圾回收，但只是提醒建议 七、错误、警告和异常 1、空引用 比如 String s=null s 就没有指向任何对象 s.方法名， s.charAt(0),如果 s 是空的话就会抛出 NullPointerException(空指针异 如 常)72、编译的问题： --错误 --警告 违背了语法的要求 3、运行时问题： --Exception 异常 程序还可以继续进行 --Error 错误 程序中断了，比如内存溢出了 编译器检查不出来，而是运行时检查出来的 违反了正常逻辑 八、运算符 赋值运算符 12 个 比如: byte a=3; a=a+5;//会报错，因为 5 是被认为是 int，所以 a+5 得到的也是 int，无法把 int 值 赋给 byte a+=5;//不会报错，因为不管运算符右边得到的是什么类型都会把右边得到的值转 化为左边的类型 关系运算符 算术运算符 1、移位运算符：只能针对二进制数据（整数） && 左移， 左移一位相当于原来的数乘二， 大于 32 位的话高出的位就不要了,如果 移动的位数大于 32 的话 java 会自动把这个位数变为这个数对 32 求余的值。 && 右移，右移一位相当于除 2 取整，两位相当于连续次除 2 取整而不是除 4 取 整，看正数还是负数， 正数右移的话高位补 0，负数的话补 1。 &&& 无符号右移（算数右移） ，不考虑符号位，移进来的都补 0。 2、位运算符 & 按位与 两个数按位与，全部转换成二进制后按位比较，全为 1 才是 1，其它 是 0，返回一个新的整数 | 按位或 两个数按位与，全部转换成二进制后按位比较，全为 0 才是 0，其它是 1，返回一个新的整数 ^按位异或 两个数的二进制位数比较，相同结果为 0，相异结果为 1 ~按位求反 把一个数二进制的每一位都反过来 3、逻辑运算符 && 短路与，两边如果左边是假的话就不再判断右边的，直接返回假 || 短路或，两边如果有一个为真的就不再判断右边的，直接返回真 & 与，不管怎样两边都会判断，都为真才返回真 | 或，不管怎样两边都会判断，都为假才返回假 4、条件运算符（三目运算符） ? : 如果?前面的返回真，那么就执行问?与:之间的，如果返回假，则执行:后面的 5、自加和自减8++ 前++的话属于先加后用，后++的话先用后加 -- 前--的话属于先减后用，后--的话先用后减 前++先自增后运算(用自增后的数运算) 后++先取运算数后自增(用自增前的数运算) 6、运算符的优先级：从高到低 --最高的：(),[],. --第二高的：++,--,+(正)，-(负)，，~ ！ --算术运算符 --移位运算符 --关系运算符 --位运算符 --逻辑运算符 --三目运算符 --赋值运算符 优先级相同的根据结合性从左到右算或从右到左算 第三章 流程控制 重点放在循环的构建上 一、if(boolean){ ... } 或 if(boolean){ ... }else{ ... } 或 if(boolean){ ... }else if(boolean){ ... }else{ ... } 二、switch(..){ case ..:......; case ..:......; ... default:....; } 1、switch 后括号中的值必须是 int，byte，char，short，枚举类型的变量之一，其 它类型的就不行了。 2、每个 case 后面的值必须是不相等的，而且必须是常量 3、如果每个 case 冒号后面的语句执行完后没有 break，还会继续执行后面 case 里9的语句，所以在每个 case 的语句结束后加一个 break 4、default 代表如果和所有 case 后的值都不匹配，就执行这里的语句。无论 default 写哪都是最后执行的。 System.exit(0); --如果系统执行到这条语句的话程序就退出了 break 和 continue 后面可以加下标，跳出循环和继续循环。 四、for 循环 --语法 for(1;2;3){ ... } --写在 1 的地方是给一个值初始化， 位置的是退出循环的条件， 2 一般是 1 位置的 变量到什么程度退出循环， 3 位置是 1 位置值的变化 当第一次循环结束后执行一遍 3 位置， 然后接着判断 2 的位置的值是真还是假， 假就退出，真的话接着循环 循环的顺序便是 1--&2--&循环体内代码--&3--&2--&如果为真继续执行循环体内 代码--&为假退出循环 五、while 循环 --语法 while(boolean){ ... } --每循环一次就判断括号中的代码是不是为真，是真的话就继续循环，假的话就 结束循环 六、do..while 循环 --语法 do{ ... }while(boolean); --无论如何都会先执行一次再判断条件是否为真，其它的和 while 循环规则一样 七、用循环来检测输入（主要是教学生利用控制台读取参数的方法） 1、用流的方式 --BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 2、用 java.util 包中的 Scanner 类 Scanner sca=new Scanner(System.in); sca.next(); 具体的代码已经写出，在代码的 day02 n夹里1 0CoreJava DAY03 数组############################################################################### ########## CoreJava DAY03() ############ ########## Made by NieXu ########### ############################################################################### 一、循环嵌套 主要是通过联系来讲的 1、讲昨天的作业，输出金字塔 2、打印 99 乘法表 见练习：Multiplication 3、搜索
之间的数字，条件：千位&百位&&十位&个位&&千位+个位&& 百位+十位 见练习：ForLoopTest 二、数组11--一维数组 1、声明数组 语法： --类型[] 数组名 or 类型 数组名[] 比如：int[] a 或者 int a[] 2、声明数组只是声明了一个数组的引用，并没有在内存中给数组开辟空间 数组是被当作对象来处理的，所以要初始化，语法： --类型[] 数组名=new 类型[长度] 比如：int[] a=new int[10]; 3、遍历数组 for(int i=0;i&a.i++){ System.out.println(a[i]); } 注意：数组的下标是从 0 开始的，所以最后一个数组元素的下标为数组长度减 1 4、也可以在初始化数组的时候就给数组赋值 比如：int a=new int[]{1,2,3,4};//声明了一个长度是 4 的 int 数组，里面的值为 1234 上面的内容还可以简写为：int a={1,2,3,4}; 注意：只有实例化数组的时候才可以给数组一次性赋值，以后就只能单独赋值 了 --二维数组 1、声明二维数组 语法： --int[][] 2、实例化 语法： --int[][] ia=new int[3][5]; 这样就声明了一个三行五列的二维数组 3、声明时赋值 4、不规则数组，也就是每一行数组的长度不一样 --就可以先声明的时候只指定第一维的下标 int a=new int[3][];//这样数组定下来是三行，但是每一行多少长度是未知的 对每一行实例化： a[0]=new int[5]; a[1]=new int[3]; a[2]=new int[4]; 那么这样这个数组就成为了一个第一行长度是 5，第二行长度是 3，第三行长 度是 4 的不规则二维数组 5、遍历二维数组 for(int i=0;i&a.i++){ for(int j=0;j&a[i].j++){ System.out.println(a[i][j]); } } 注意：数组也是个对象，所以 Object obj=new float[10];是成立的。 存放对象类型数据的数组1 2每个数组元素存放的都是对象在内存中的地址，都是对象的引用 --数组的辅助工具类和方法 1、数组拷贝： System.arraycopy(myArray,0,hold,0,myArray.length); 方法参数从左到右依次是原数组，原数组拷贝起始位置，目标数组，目标数组起 始位置，拷贝数组长度 2、数组工具类 java.util.Arrays，带学生查 API 3、数组元素的查找： --线性查找：从第一个开始查找 --二分法查找：要求数组必须有序，就是从数组元素中间开始找，然后比较这个 结果和要查找数组的大小， 再决定从哪边再开始找 三、eclipse 开发工具介绍 1、目录，在/opt 目录下有个 eclipse 文件夹 2、打开 eclipse 可执行档 设置好存放编码的目录（workspace）后进入开发工具 一开始出现欢迎界面，把它 X 掉。 3、怎样创建一个工程 --在左边空白处点右键，new--&java project--&写上 project name（工程名）--&next --&create new source folder(创建存放 java 文件的目录)命 名为 src --&finish--&finish 这种创建工程的方式是把 java n和 class n分开的，视频上没有讲，请项目经理 注意强调这种建法 4、在 src 目录上点右键 new--&package 建立一个包命名为 day01（存放第一天的代 码） 5、在 day01 包上点右键 new--&class 建立一个类，写上名字 finish 后在就可以在这 个n里写 java 代码开发了 6、写好代码后运行，在代码区域点击右键--&run as--&Java Application 四、讲昨天的作业 1、计算工资个人所得税的题目 2、倒排数字 练习：输入 1-100 之间所有的素数，见课堂代码 PrimeNumber.java 五、在主方法之外定义自己的方法 1、定义语法：在主方法之外，类范围以内 修饰符 返回值 方法名(参数类型 参数名){ ... } 比如： public static boolean isPrimeNumber(int i){ ... } public static 是修饰符，boolean 是返回值类型，isPrimeNumber 是方法名，括号 里是方法的形参列表1 3注意：只要返回值不是 void，无论如何都要返回一个返回类型的值，return 2、调用方法的过程 1、为被调用方法分配临时存储空间（栈） 2、把实参值传给形参 3、程序流程跳到被调用方法中执行 4、被调用方法执行完成，程序流程跳回主调方法并且带回返回值（如果有的话） 与此同时，被调用方法的临时空间被释放 六、方法的递归调用 一个方法直接或间接调用自己的形式，解决比较复杂而且有一定规律的逻辑问题 练习用递归求一个自然数的阶乘，代码见课堂代码 MethodTest.java 七、讲昨天的作业 1、打印诗 2、酒店管理系统1 4CoreJava DAY04############################################################################### ################# CoreJava DAY04() #################### ################# Made by NieXu #################### ############################################################################### 今天没有讲新的内容，首先讲了昨天两道作业题，然后老师又布置了四到联系题，如 下： 1、猜数字游戏 游戏产生一个 0-1000 的整数，让用户从控制台输入一 个数字来猜，如果猜大了就显示太大了，继续要求用户 输入，如果猜小了就显示猜小了，如果猜对了，就显示 恭喜你，猜对了，游戏结束，如果猜了 10 次还不对，那么就显示 你太笨了，下次再猜吧，游戏结束 2、五子棋游戏，游戏开始要求 输出一下棋盘，然后提示黑方和白方下子，玩家从 命令行输入：af，表示在 af 坐标落子，其中黑方的 子用@表示，白方子用 O 表示，每一方有一方落子， 则要重新输出棋盘的状态，程序还要求能判断某一方 获胜并终止程序。 棋盘初始样子如下： a b c d e f g h i j k l m n a b c d e f g h i j * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *1 5k l m n* * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * ** * * *3、砸金花游戏 编写程序模拟砸金花的游戏，程序开始时要求用户输入 赌注，并在一副牌中随即发两手牌，每手牌三张，然后比较这 两副牌大小，若 A 比 B 打，则用户赢得赌注，反之则输掉赌注 比较规则： 1、三条》同花顺》同花》顺子》对子》三张 2、处于同一级别的两手牌比较最大的一张牌的大小 3、若两手牌都是对子，则应比较成对的那张牌的大小 4、扫雷游戏 要求在 10x10 矩阵中随机布雷，并计算出每个位置周围的地雷数， 并保存在二维数组中，若该位置是地雷，则保存-1，然后要求用户 从命令行输入坐标来排雷，排雷使用一下两种命令： b 3 6：将坐标 3，6 标志为地雷 p 2 5：排除 2，5 坐标位置是地雷
0 1 2 3 4 5 6 7 8 9 以上代码都已经写出，就在课堂代码中1 6CoreJava DAY05 面向对象4 minutes ############################################################################### ########## CoreJava DAY05() ############# ########## Made by NieXu ############# ############################################################################### 今天上午讲了昨天的课堂练习代码五子棋游戏和砸金花游戏和扫雷游戏，代码参见昨 天 day04 的课堂代码 下午是新课面向物件 一、面向对象 编程要解决的本质工作： 把现实问题抽象成计算机能解决的问题,对现实问题在计算机中建模（抽象） 抽象： 1、对数据的抽象 2、业务逻辑 设计思想：D一切皆对象‖ 对象--&数据--&类--&数据类型 二、类 1、创建类的语法： public class 类名{ 类型 变量名; 类型 变量名; ... public void 方法名(){ ... } public void 方法名(){ ... } ... } 例子： public class Animal{ S ... public void eat(){ ... } public void move(){ ...1 7} ... } 2、创建类的对象的语法： 类名 对象名=new 类名(); Animal a=new Animal(); 调用对象的成员 对象名.属性名; 对象名.方法名(); a.name=...; a.move(); 3、构造方法： 用处： 1、构造方法一般用来为属性赋初值 2、构造方法会在生成对象时被系统自动调用 特点： 1、没有返回值，写返回值的位置什么都不写 2、方法名必须和类名完全相同 构造方法也可以定义参数，也可以在里面写实现代码 但是如果一个类中只有一个构造方法， 并且这个方法是有参数的， 那么在创建类的对象 的时候也要传参数。(当类中定义了构造方法，系统就不会再添加无参的构造函数了。) 如果类里没有写构造方法，在创建对象的时候同样会被虚拟机调用其构造方法，因为： 任何类都有构造方法，如果程序员不定义，则系统会加上一个缺省的构造方法。 比如：如果 Animal 没定义构造方法，那么系统会自动给这个类加上 public Animal(){} 这样一个无参空实现的构造方法。 如果自己定义了构造方法，则系统就不会添加这个缺省的构造方法。 4、this 的用法 this 等价于当前对象，调用当前对象的属性或方法就用 this.属性名，或 this.方法名()。 当前对象：指谁在调用当前这个方法和属性，谁就是当前对象。在定义类的时候是不存 在当前对象的。 在局部变量与外部变量同名的时候，为了区分，就要在外部变量的前面加一个 this 来表 示这个变量是类的全局变量。 5、访问控制修饰符： public： 公共的， 如果用这个修饰属性和方法， 则这个属性和方法能在任何地方被调用。 private：私有的，如果用这个修饰属性和方法，则这个属性和方法只能在类的内部被使 用。 修饰符的作用：封装类 6、封装： 如果一个数据类型， 把它不想让外部知道的属性和方法私有化， 把它能让外部访问的属 性和方法公共化，这就叫封装。 属性最好是被封装在内部的，因为这样公开自己内部信息的主动权就在自己身上。 现实世界的所有个体我们都可以看成一个封装体， 因为他们对外展现的都只是其一部分 特征行为。1 8但是属性的隐藏不是最终目的，是为了让外部更好的、更安全的去访问。 定义访问方法：setXXX(),getXXX() 访问的方法格式是固定的 获得属性值的方法必须返回类型是属性的类型，方法名为 get 属性名()， 设置属性值的方法参数类型必须是属性的类型， 方法名为 set 属性名(属性类型 变量名)， 以上方法名还要满足方法的命名规范，比如 public void setName(String name){ this.name= } public String getName(){ return this. } 那么以后再给对象的属性赋值就写成 a.setName(&xiaoqiang&); 获得属性的值就写成 a.getName(); 封装的好处：代码维护方便，如果属性名变了，其它程序根本不用做改动，还是调用 这个控制属性的方法就行了 7、方法的重载：一个类中同名但参数不同的方法 this(..,..);调用本类其它的构造方法 this(..,..)这样的调用只能出现在构造方法的第一行1 9CoreJava DAY06 类的加载过程、实例化、继承、多态12 minutes ############################################################################### ########## CoreJava DAY06() ########### ########## Made by NieXu ########### ############################################################################### 回顾： 数据-&类 一是要描述数据的静态特征（属性） ，一是要描述其动态行为（方法） 。 生成对象，构造方法的调用 当生成对象时，比如：Animal a=new Animal()时，系统做了三件事： 1、给对象在堆中分配空间 2、给对象的属性初始化 boolean 赋值为 false， char 类型的值转换成 int 是 0 其它基本类型就赋值为 0，或 0.0 引用类型赋值为 null 3、调用构造方法 方法的重载/构造方法的重载 一个构造方法中调用本类其它的构造方法 this(..,..);只能放在构造方法的第一行 类的封装 属性隐藏-&提供公开的访问方法 Java 类的加载过程： 传统语言程序在启动（startup）过程中程序会被全部装载，紧接着进行初始化动作，然 后开始执行。由于 Java 中每样事物都是对象，装载动作就大不相同了。 每个 class 都存在于一个单独的专属的n中，这个n只在必要时才被 JVM 装载（根据 CLASSPATH 的设置找到类文件） 。一般而言，可以这么说：Dclass 程序代码在初次使用时才 被装载‖。所谓初次使用，不仅是其第一个对象被构建时，也可能是在某个 static 数据成员 或 static 函数被取用时。类被装载的完毕，正是静态初始化的进行时期（静态初始化只在类 被装载时进行一次） 。 如果类是继承而来的，那么装载动作在检测到 extends 关键词是转去装载父类（所以父 类的进态初始化会在子类之前进行） ，以此类推。 类装载完毕并进行了静态初始化以后，就可以用类创建对象了（用 new 关键词） 。这时 会涉及到构造函数的调用，当有继承关系时，情况会比较复杂。在构造函数调用之前，进行 两件事情：给对象分配存储空间（数据区，代码区是怎么分配的呢？） ；存储空间被初始化 为二进制零值。2 0Java 编译器D强迫 derived class 构造函数必须调用 base class 构造函数‖。 derived class 的 构造函数会默认（不用显示写代码，当然可以用 super()，这在调用 base class 的带参数的构 造函数时有用）调用 base class 的 default 构造函数。其实构造函数首先会默认调用各数据成 员的初始式（形如：int id = 1000;） ，然后才执行构造函数体。 在定义属性的位置上，在任何方法之外，定义一个代码块： （代码块的载入） 动态初始代码块：在初始化属性之前调用初始化代码块{……} 静态初始代码块：在类载入时运行 static{……} 只被运行一次，往往用作一个类的准备工作 类的加载过程： A. new 一个对象的时候-------加载 B. 没有创建对象，访问类中静态成员（方法和属性）-------加载 C. 声明一个类的引用-------不载入 D. 创建子类，先载入父类，再载入子类 E. 父类中的公开静态方法，子类继承，使用子类的类名调用此方法，只加载父类 class Super{ public static m(){} } class Sub extends Super{} 在主函数中运行以下代码： Sub.m(); //加载了父类之后，虚拟机已经知道 m()方法的调用了，就不会再加载 子类 对象实例化过程： 1.类加载，执行静态语句块和静态的属性赋值（先父类后子类） 2.预开空间，所有属性设零值 3.实例化对象： （先父类后子类） 1)初始化所有的属性，和非静态语句块(自上而下执行) 2)构造函数 类加载的顺序: [具体顺序是：先加载父类的 static 代码块，再加载子类的 static 代码块； 再加载父类的代码块，再调用父类的构造方法； 在加载子类的代码块，再调用子类的构造方法。 ］ 1.加载静态成员/代码块: 先递归地加载父类的静态成员/代码块(Object 的最先);再依次加载到本类的静态成 员。 同一个类里的静态成员/代码块,按写代码的顺序加载。 如果其间调用静态方法,则调用时会先运行静态方法,再继续加载。同一个类里调用 静态方法时,可以不理会写代码的顺序。2 1调用父类的静态成员,可以像调用自己的一样;但调用其子类的静态成员,必须使用 D子类名.成员名‖来调用。 2.加载非静态成员/代码块: 先递归地加载父类的非静态成员/代码块(Object 的最先);再依次加载到本类的非静 态成员。 同一个类里的非静态成员/代码块,按写代码的顺序加载。同一个类里调用方法时, 可以不理会写代码的顺序。 但调用属性时,必须注意加载顺序。 一般编译不通过,如果能在加载前调用,值为默认 初始值(如:null 或者 0)。调用父类的非静态成员(private 除外),也可以像调用自己的一样。 3.调用构造方法: 先递归地调用父类的构造方法(Object 的最先);默认调用父类空参的,也可在第一行 写明调用父类某个带参的。 再依次到本类的构造方法;构造方法内,也可在第一行写明调用某个本类其它的构 造方法。 注意:如果加载时遇到 override 的成员,可看作是所需创建的类型赋值给当前类型。 其调用按多态用法:只有非静态方法有多态;而静态方法、静态属性、非静态属性都 没有多态。 假设子类 override 父类的所有成员,包括静态成员、非静态属性和非静态方法。 由于构造子类时会先构造父类;而构造父类时,其所用的静态成员和非静态属性是 父类的,但非静态方法却是子类的; 由于构造父类时,子类并未加载;如果此时所调用的非静态方法里有成员,则这个成 员是子类的,且非静态属性是默认初始值的。 成员,包括变量和方法 成员变量,包括实例变量和静态变量今天内容： 一、类中方法的调用： 1、方法调用的四个步骤： --首先在栈中给方法开辟空间2 2--其次把实参传给方法的形参 --再次程序跳到被调用方法中执行方法中的代码 --最后方法中的代码执行完后再跳回主方法 2、方法中的对象类型的参数传递只有引用传递，没有值传递。 --这是因为方法和参数都是存在于栈中的，当此方法执行完毕后，参数和方法都 被释放了，所以不会保留值。 --而对象类型的参数传递的是对象的内存地址，那么无论如何改变，都是改变的 这个地址的对象，即使方法结束了。 --方法空间释放了，对象并没释放（因为对象是存在于堆中的） ，所以方法中对对 象的改变是改变的同一个对象。 --但是如果方法中写的代码是对象地址的交换，并没有改变对象的话，原对象的 地址还是没有变的。 二、继承（代码重用） 1、语法--&public class 子类名 extends 父类名{ ... } 2、子类的对象可以调用父类的一切公有的变量和方法，也可以扩展自己新的属性和 方法，但是新扩展的部分父类的对象是无法调用的 3、super(..,..)的用法，在子类的构造方法中调用父类的构造方法，并且 super 要放在 第一行，不能与 this 一起用 主要用为在构造子类的时候给父类中定义的变量赋值 4、子类的一些特点 --任何子类的构造方法都会调用父类的构造方法 --任何子类的构造方法的第一行必须是 this(..,..)或 super(..,..)的调用，如果程序员 不写，则系统会隐含的调用 super() 也就是说，子类不管怎样一定会调用父类的构造方法 5、为什么子类的构造方法一定要调用父类的构造方法呢 因为如果构造了子类的对象就一定要构造父类的对象，从反方向来讲，虚拟机会 先创造一个所有类的父类对象出来，然后再对这个对象扩展，最后生成子类对象，也就是说 D没有父哪来子呢‖这个意思。 就像上帝要创造一个科学家， 他必须先创建一个人的对象出来， 然后再让这个人去研究科学（扩展） ，最后形成科学家对象（子类对象） 6、构造了一个子类对象其实也只是创建了一个对象，只不过父类对象是子类对象的 一部分，就像上帝要创造一个科学家只是创造了一个人而已。 7、如果父类的属性和子类的属性同名的话，首先来说，现实中不会有这样的需求， 完全没有必要在子类中定义与父类同名的属性。 如果确实定义了的话， 直接用 name 或者 this.name 就是调用的子类的 （就近原则） ， 要想调用父类的就要 super.name 或 super.getName(); 8、如果父子类中有同名的方法，如果同名不同参，返回类型可以相同也可以不同， 只是一种重载；如果是同名同参的话，那子类对象调用的这个方法便是子类自己的， 这种 子类与父类存在同名同参的方法的形势叫做方法的覆盖（重写） ，也就是子类的方法把父类 的覆盖了。 覆盖用来描述子类和父类有相同的行为，但两者行为方式是不同的，比如 Animal 可以 移动，但是子类 Bird 可以飞。 方法覆盖的原则： --发生在父子类之间 --同名，同参，同返回类型(可以返回子类型)2 3--子类的方法的修饰符不能比父类方法的修饰符更封闭，比方说父类的是 public， 子类的就不能为 private --抛出异常类型不能更宽泛 三、多态 1、方法的重载和覆盖就是方法多态的一种体现 2、对象的多态，一个对象多种形态，这要取决于对象的继承关系 表现对象多态的一种形式，把子类对象当作父类对象的一种形式：父类名 对象 名=new 子类名();--&Animal a=new Bird(); 但是这样的话，此对象不能调用父类中没有的方法 4、多态定理： --如果我们把子类对象当作父类对象来看，那么就只能访问父类中已有定义的属 性和方法（不能访问子类扩展的属性和方法） --如果子类覆盖了父类的方法，再把子类对象当作父类对象去调用该方法时，调 用的是子类覆盖后的方法。 （对象的行为不可能因为你把它当作什么来看而改变） Animal a=new Bird(); |------| |--------| | | 主观认为 客观存在 编译时类型 运行时类型 编译时类型： 在写代码编译过程中， 编译器把这个对象当作什么来看 （父类对象） 运行时类型：在代码执行过程中，JVM 把这个对象当作什么看（子类对象） 5、instanceof，判断一个对象是不是某一个类型的实例，用法 对象名 instanceof 类名; 返回一个布尔值，如果前者是后者的实例则返回真 一般这样用： Animal a=new Bird(); //如果 a 是 Bird 的实例，做什么 if(a instanceof Bird){ Bird b1=(Bird)a; a.sing(); } 并不是所有的父类都能转换成子类 如果任意强转不匹配的类型就会抛出 java.lang.ClassCastException 类型转换异常：把一个原本不是这种类型的对象强转成这种对象 所以在强转之前最好用 instanceof 做一下判断，如果是这种类型的实例再强转2 4练习： 1、定义以下数据类型 Person：String name ， int age 构造：第一个的参数 String name，int age 第二个的参数 String name ，age 默认为 20 要在第二个构造方法中调用第一个 public void work(); Person 的子类: Student:覆盖 work()方法，输出学生在学习。 Teacher:覆盖 work()方法，输出教师在授课。 在以上两个子类的构造方法中调用父类的构造方法，通过构造方法把 name 传给 父类 2、使用面向对象的思想设计一个即使战略游戏的类结构 主要类如下： 1、人口类（Person） 属性：生命值(lifeValue),攻击力(attackPower),消耗资源数(needResource) 方法：进攻(attack) 子类： 工 兵 （ Sapper ） 扩 展 方 法 ： 创 建 建 筑 createConstruction() ， 采 集 资 源 collectResource() 机枪兵(GunMan) 护士(Nurse)扩展方法：疗伤(cure) 2、建筑类(Construction) 属性：生命值，消耗资源数 3、玩家类（Player） 属性：玩家名称，玩家资源值，玩家所拥有的人口对象，玩家做拥有的建筑对 象 在主方法中测试以上程序，创建两个玩家，分别生成人口和建筑类攻击对方 以上练习代码参见课堂代码。2 5CoreJava DAY07 修饰符8 minutes ############################################################################### ########## CoreJava DAY07() ############ ########## Made by NieXu ############ ############################################################################### 一、修饰符 1、static 描述整体特征而不是个体特征的属性时，用静态修饰符 --静态和非静态的差别 1、空间分配时机： 静态变量是在类加载的时候分配空间，非静态变量是在生成对象的时候分配 空间 2、空间分配方式： 不管有多少对象静态变量只有一份（所有对象共享） ，非静态变量有多少对象 就分配多少个空间 3、访问方式： 静态变量是：类名.属性，比如 Animal.COUNT 非静态变量：对象名.属性，比如 a.name --静态方法和非静态方法的区别 1、静态方法是通过类名来调用，非静态方法是通过对象来调用 2、静态方法中不能访问本类的非静态成员，但非静态方法可以访问静态成员 为什么主方法非要是静态的： 我们看执行 java Test 命令后的运行步骤 1、启动 JVM 2、找到 Test.class 3、载入 Test.class 4、Test.main(); 也就是说 main 方法是程序的入口，那么在执行 main 方法之前是执行不了任 何代码的，所以获得不了这个类的对象，只有用这个类的类名来调用 main 方法，所以 main 方法必须为 static --静态代码块 1、静态代码块会在类被加载时被系统自动执行 2、一般可以在静态代码块中给静态属性赋值 一个静态与非静态实行先后的例子，见代码 StaticTest.java 静态方法不存在多态特性，也就是静态方法无法被子类覆盖，父类对象调用此 方法还是父类的，所以虽然静态方法可以被对象调用，但也不要这样用，要用类名对其进行 调用类的静态代码块： 在类加载时被系统自动执行， 一般可以在静态代码块中给静态属性赋 初值，类的静态代码块只能有一个。 静态方法可以覆盖，但没有多态，属性也一样。静态方法只属于本类，并且不能 被子类的同名同参的静态方法覆盖。属性也一样，可以被覆盖但没有多态，子类定义相同的 属性，该属性仍然用原来本类对象的属性值。 （这里叫覆盖不合适）2 6其调用按多态用法：只有非静态方法有多态；而静态方法、静态属性、非静态属性都 没有多态。 2、final 1、修饰属性：属性不可变，并且属性在声明的时候必须初始化，或者在构造方 法中初始化一般与 static 一起用，一旦定义了，就不能再变了。 两种赋值方式有不同之处， 声明的时候初始化所有类的对象的常量都一样， 所以一 般用 static final 声明。构造方法中声明，表示类的每个对象的常量可以是不一样的。 2、修饰方法：方法不能被覆盖 3、修饰类：类不能被继承 4、修饰局部变数：局部变量不可变（常量） 3、abstract（抽象） 1、用来修饰类和方法。 2、修饰类的话表示这个类是个抽象类，抽象类不能被实例化（生成对象） 。 3、修饰方法的话表示这个方法是个抽象方法，抽象方法没有方法体。 4、如果一个类包含有一个抽象方法，那么这个类必须是抽象类。 5、如果一个类不包含抽象方法，那么该类也可以被定义成抽象类。 6、抽象类不能被实例化，但却可以定义引用。 7、抽象类一般需要实现--定义一个子类，并实现抽象方法。 8、抽象类也是有构造方法的，因为需要被子类调用。 9、子类必须实现父类的抽象方法。 --abstract 和 final 不能共同修饰一个类或方法 二、界面 interface 1、是一种抽象的数据类型，特殊的抽象类。 2、接口中的所有方法都是抽象方法。 3、接口中所有的属性都是 final static 的（静态常量） 。 4、接口也不能被实例化，但可以定义的接口的引用。 5、接口没有构造方法。 6、一个类只能继承一个父类，但是可以实现多个接口，用逗号隔开。 7、接口之间可以多继承。 --接口=标准 把服务的使用者和服务的提供者分开，降低系统的耦合，有效的提高软件的可扩 展性和可维护性 高内聚，低耦合 --基于抽象，不要基于实现 implements 实现 abstract 可以省略不写的，因为 interface 本身就是抽象的第一题2 71、定义一个接口 Assaultable（可攻击的） ，该接口有一个方法 attack（） 。 2、定义一个接口 Mobile（可移动的） ，该接口有一个抽象方法 move()。 3、定义一个抽象类 Weapon，实现 Assaultable 接口，但并没有具体的方法实现。 4、定义 3 个类：Tank，Filghter，MissileTurrent 都继承自 Weapon，分别给出 attack()方法的不同实现，Tank 和 Filghter 还实现了 Mobile 界面，也给出了 move() 方法的不同实现。 5、写一个类 Army，代表一支军队，这个类有一个属性 Weapon 数组 w（用来存储该军 队所拥有的所有武器） ； 该类还提供一个构造方法，在构造方法里通过传一个 int 类型的参数来限定该类能 所拥有的最大武器的 数量， 并用这一大小来初始化数组 w。 该类还提供一个方法 addWeapon(Weapon wa)， 表示把参数中所 代表的武器加入到数组 w 中。在这个类中还定义了两个方法 attackAll()让 w 数组中 所有的武器攻击； moveAll()让 w 中所有可移动的武器移动 6、写一个类测试以上方法2 8CoreJava DAY08 常用类############################################################################### ################ CoreJava DAY08() ################ ################ Made by NieXu ################# ############################################################################### 今天没有讲新课，上午和下午刚开始讲了两个例子说明了接口回调，下午讲了面向对 象第一天的作业和日期类型一、界面与类的关系和区别 子 父 类 extends 类（单一） 类 implements 接口（多重） 接口 extends 接口（多重） 二、例子说明问题 1、开发电子商务的网上平台，都有客户管理模块， 实现注册和登陆功能 见课堂代码 user_management 包 2、把不同的数据用二维表格输出 存放方式，二维字符串数组 见课堂代码 table 包 三、java.util.Date 类 --已经过时，基本没人用了，因为没考虑时区问题 四、java.util.Calendar --int get(int field) 返回给定字段的日期值2 9CoreJava DAY09 高级语言特征4 minutes ############################################################################### ############### CoreJava DAY09() ################## ############### Made by NieXu ################## ############################################################################### 第六章、高级语言特性 1、访问控制修饰符 本类 同包 子类 其它类 public YES YES YES YES protected YES YES YES NO (所定义的成员受包和继承 结构的保护) 不写修饰符 YES YES NO NO private YES NO NO NO static final abstract public protected default private 顶层类 N Y Y Y N Y N 属性 Y Y N Y N Y Y 方法 Y Y Y Y Y Y Y 局部变数 N Y N N N N N （protected 是可以定义属性的） 2、java.lang.Object 类 --只有一个无参构造方法 --其它方法 11 个，必须全部明白 clone():创建并返回一个当前对象的拷贝，得到和当前对象一模一样的对象，地址是不 同的 这个方法是让子类覆盖的，但子类也必须同是实现 java.lang.Cloneable 界面 对象克隆过程：1、要让这个类实现 Cloneable 界面 2、要覆盖 Object 中的 clone()方法 深拷贝和浅拷贝：浅拷贝只是把当前对象拷贝了，但是当前对象中有存在对别的对 象的引用的属性，那么那个属性还是指向同一个对象。所以如果直接调用 clone()方法的话 就属于浅拷贝。 如果这个类里只有字符串对象和基本数据类型，那么也属于深拷贝。 finalize():垃圾回收器调用 equals(Object obj):判断两个对象是否相等 --反身性：对任意非空的值调用此方法自己和自己比应该返回真 --对称性：对任意非空的引用值 x 和 y，如果 x.equals(y)返回真，那么反之亦然 --传递性：x，y，z，x.equals(y)返回真，x.equals(z)返回真，z.equals(y)也应返回真 --一致性：结果应为确定的，如果对象不变，无论调用多少此都返回相同结果 --对于任意非空的引用值和空比较都应返回假 toString()：输出对象时输出这个方法的返回值 System.out.println();方法输出的对象和对象的 toString()方法， 的结果是一样的。 也就3 0是说输出一个对象的时候，系统会自动调用 toString()方法。 如：Student s=new Student(…); System.out.println(s); System.out.println(s.toString()); String str=‖Hello‖+s; 3、java.lang.String 类 如果 String s1=&hello&这样直接赋值的话，那么与同样直接赋值的比较如果字符串相等 的话就相等。 如果和 String s3=new String(&hello&);这样的对象比较的话如果字符串相同才返回假 java.lang.StringBuffer 线程安全 java.lang.StringBuilder 线程不安全 --以上这两个类如果对字符串做修改的话不会创建新对象，只是在原来对象基础上改 这是为什么呢？ --串池： 存储字符串的地方， 如果有新字符串对象生成的话那就继续生成新的字符串， 如果想要新生成字符串的话而此字符串在串池中已经有了的话就直接用已经有的。 对象池中 的数据不会成为垃圾。3 1CoreJava DAY10 主方法，静态导入，包装类，枚举############################################################################### ############### CoreJava DAY10() ################## ############### Made by MoXiaoMing ################## ############################################################################### AM: 1、对象池 一般我们获得一个类的对象都是通过 new 的形式，如果不用这种形式的话我们就可以写 一个获取对象的方法来获取对象。 原理： 我们生成对象以后便把此对象保存到对象池中，这样我们用完了此对象也不会被释放， 以后我们再用到此对象的时候就直接在对象池里取就行了。 我们可以先在类中创建一个此类对象的数组，要声明成静态的。 然后在此类中写一个获得对象的静态方法， 一定要是静态的， 不然获得对象的方法就没 有什么意义了。 2、主方法（main）声明的参数由谁传递呢 java 类名 命令所做的： --启动虚拟机 --找到 class 文件 --载入类 --调用这个类的 main 方法 所以运行 java 类名 命令后面还可以给一些主方法的参数，这些参数都被系统当作字 符串放到 main 方法声明的参数 String[] args 中， 如果输入多个参数的话就以空格为分隔符依 次把每个参数放入 args 数组，比如 java HelloWorld hello world ； hello 和 world 就是两个 参数 如果不传参数的话 args 就是一个 0 个元素的数组 在 eclipse 中给主方法传参数：右键 run as--&run configurations..--Main class 要是现在要 运行的类，如果不是就要 search 找到--&arguments--&在上面的栏中就是给 main 方法传的参 数，填上参数--&apply--&Run 3、可变长参数 在定义方法的时候知道要传的参数的类型， 但是参数的数量不固定的时候就用可变长参 数，可变长参数类型的写法是:例子：public static void m2(String... strs){ ... } 上面的参数类型在 String 后面多了...，这样在调用方法传参数的时候就可以传多个参数 或者一个参数，也可以不传参数，但参数必须都为 String 类型的，如果要传其它类型的时候 在定义的时候改成其它类型，然后在类型后面加上...就可以了。 如何使用这些参数： 在方法中此参数是被当作数组类访问的， 调用 length 就可以知道有 多少参数传进来，这种参数既能接受单个元素做参数，也可以接受数组作参数。也就是说可 变长的参数类型兼容了数组参数类型，但是数组参数类型不能兼容可变长参数类型。 使用可变长参数的规定： --一个方法只能有一个可变长参数，而且该参数必须是这个方法的最后一个参数 --可变长参数的方法只有在必须的时候才被调用，也就是说，如果有不可变长参数的方 法可以匹配，这种调用，那么系统会优先选择不可变长参数的方法的调用3 24、静态导入 一般我们导入的话用 import，后面跟的是一个类，或者此包的所有类 我们要用某个类的静态属性或方法的时候可以不用导入这个类， 我们可以直接把这个类中 的静态属性导入进来： 语法： import static 包名.类名.属性名 比如 import static java.lang.System. 这样的话我们在写输出语句的时候就可以直接写成 out.println(...); PM: 1、包装类 针对八种基本类型的包装类， 在基本类型和对象类型之间建立桥梁， 使基本数据类型也可 以当作对象来用 基本数据类型 boolean byte short char int long float double 包装类 Boolean Byte Short Character Integer Long Float Double--java.lang.Integer 类 注意查 API 构造方法 Integer(int),Integer(String)--&例如：new Integer(&123&); parseInt(..);可以把不是 int 类型的数据转换成 int 类型，是静态的，可由类名直接调用 --这些包装类中很中要的一些方法是类型的相互转换 --在 JDK1.5 之前要获得一个基本类型的对象比如 Integer 只能用 Integer i=new Integer(5)或 者 Integer i=Integer.valueOf(5) 但在 JDK1.5 以后可以直接写成 Integer i=5;在这里虚拟机默认的为这个基本数据类型进 行了包装，以上面的第二种形式即:Integer i = Integer.valueOf(5);包装了。这种自动的包装叫 做自动封箱，另外还可以自动解封，比如：int a=i;这种形式就相当与 int a = i.intValue();3 3Integerw ne In(i);s er( tegalu eO f();;I tr)i.i nt Va lu eteg er. v; tr) f(s eO alu r.v ge nteoS i.t;Inn triteg er( i)g( );ne wInInteger.parseInt(); int Integer.toString(i);i+””;”“+i Stringint Integer String 三者的转换 要注意： 除了字符串类型的对象会创建对象池， 八种基本类型的包装类也会创建对象池。 但是这 些包装类 new 出来也只创建一个对象，Integer 的对象池在启动的时候就创建好了，范围是 -128~127 之间，所以在这之间的数字对象都不会再创建新对象，超出的部分都会再创建新 对象,不会在从对象池中拿。 2、枚举类型 --什么叫枚举？ 比如一年的季节，一周中的七天，都是固定的，依次出现的 --枚举用来限制一定得取值范围 --定义声明枚举类型语法： public enum Season{ SPRING, SUMMER, AUTUMN, WINTER; } public enum Season{ SPRING(D春天‖), SUMMER(D夏天‖), AUTUMN(D秋天D), WINTER（D冬天D）; Private S Private Season(String name){3 4This.name= } } public class Season{ public static Season SPRING=new Season(D春天‖); public static Season SUMMER =new Season (D夏天‖); public static Season AUTUMN =new Season (D秋天D); public static Season WINTER =new Season(D冬天‖); Private S Private Season(String name){ This.name= } } 上面两种方法可以对应和相互转换的，但是有不同的地方是，他们的公共父类不一样，class 的是 Object，enum 的是 Enum 注意：枚举类型中的枚举值，如果后面没有语句，分号（； ）可以省略。 public enum Season{ SPRING, SUMMER, AUTUMN, WINTER } 枚举类型，标准是用类名应用类型枚举值，如：Season.SUMMER JDK1.6 中 static Ss.SUMMER;这样的也可以编译通过。 枚举类型不可以是在局部定义，不如：在一个方法中定义，因为枚举类是从一个属性 和方法都是静态的类，而静态的方法和类是不可以存在在局部中的。 上面声明了一个枚举类型 Season，也可以把枚举看作一个类。 枚举里可以定义属性，构造方法，但是都必须定义成私有的，也可以定义方法，修饰符 无限制 注意：switch()里面可以放入 byte、short、int、char 和枚举类，以及 byte,short,int,char 的 包装类。 练习： 1、改砸金花(用面向物件枚举等) 请见课堂代码中的砸金花项目文文件3 5CoreJava DAY11 内部类############################################################################### ############### CoreJava DAY11() ################## ############### Made by MoXiaoMing ################## ############################################################################### AM: 一、所有枚举类型的父类 java.lang.Enum --name()方法，返回此枚举值的名字，必须由枚举的对象来调用 --ordinal(),返回此枚举值在枚举声明中的次序，从 0 开始 --在文n中查不到的方法 values(),静态方法，由枚举类型名直接调用，返回此枚举类型中 所有枚举值的一个数组 二、内部类 inner class 为的是隐藏一种数据类型，这种数据类型只在一个类中可见。 就像生物圈中的寄居、寄生。 四种形式的内部类： 静态内部类-|-成员式的（存在于类体中） 成员内部类-局部内部类-|-局部式的 匿名内部类-内部类的修饰符： static final abstract public protected default private 顶层类 N Y Y Y N Y N 属性 Y Y N Y N Y Y 方法 Y Y Y Y Y Y Y 局部变数 N Y N N N N N 成员式内部类 Y Y Y Y Y Y Y 局部式内部类 N Y Y N N N N 局部变量和局部类（在方法体中）只能使用 final，局部类类多一个 abstract，其它的修饰 符都是不可以的。 内部类可以访问外部类的私有成员。 如果要访问内部类的话 1、静态内部类： --不能访问外部类的非静态成员 --在外面访问此类的话就用 外部类名.内部类名 比如 OuterA.InnerA inn=new OuterA.InnerA();创建了一个静态内部类对象 --静态内部类和外部类对象实际上是没什么关系的 补充： 静态内部类：作为一个类成员存在 修饰符和成员内部类相同 public protected (Default) private abstract final static 不能访问外部类的非静态成员，可以访问静态成员3 6实例化(new 外部类名.内部类构造函数()) 声明(外部类名.内部类名 变数) 静态内部类里可以定义静态的属性和方法 2、成员内部类： --可以访问外部类的静态和非静态成员 --访问成员内部类必须先生成一个外部类对象，生成局部内部类的对象用 外部类名.内部类名 对象名=外部类对象.new 内部类名(); 比如：OuterA out=new OuterA(); OuterA.InnerB innb=out.new InnerB(); --如何选择用静态内部类或成员内部类： 如果外部类怎么变化都不影响内部类的话，那么推荐用静态内部类， 如果操作内部类的改变能影响外部类，那么推荐使用成员内部类。 补充： 成员内部类：作为一个对象(实例)的成员存在 修饰符可以是 public protected (Default) private abstract final static 可以访问外部类的成员(外部类名.this.成员) 实例化(外部类对象的引用.new 内部类构造函数()) 声明(外部类名.内部类名 变数) 成员内部类里不能定义静态的属性和方法 3、局部内部类 --在方法体里定义的类 --如何在方法体外得到这个类的对象呢，通过方法的返回值就可以，返回值类型为 Object。 但是外部得到的这个对象是没什么意义的，因为只能访问 Object 里的方法，此类自己 的方法是访问不到的。 解决方法： 1、覆盖 Object 类的方法，此方法不推荐。 2、在外部定义一个接口，然后此局部内部类来实现接口，然后哦外部拿到对象后转化 成此接口类型就行了。 3、反射技术 --局部内部类中不能访问外部方法中的局部变量，如果要访问的话，局部变量必须是 final。 因为对象是存在于堆中的，而方法是存在于栈中的，对象对方法中局部变量访问的话就 要创建局部变数的一个副本来存放此局部变量的值， 所以其中有一个改变了， 另外一个是不 会改变的，所以为了保持一致性，要把这个局部变量定义为 final。 --局部内部类中不能生成静态成员 补充： 局部内部类：定义在方法体里的类 修饰符可以是 abstract final 可以访问外部类的成员 声明和实例化跟普通类一样 局部内部类里不能定义静态的属性和方法3 7局部内部类只能访问 final 修饰的局部变数4、匿名内部类 --没有名字的类 --匿名内部类的声明： 声明类型 变量=new [类名 extends/implements] 声明类型(){ 类的方法声明... } []中的是省略的部分 --匿名内部类的声明和对象的生成是合二为一，不可分割的 得到的对象不知道是哪个类的对象， 只知道是实现了某接口或者继承了某类的类的 对象 --匿名内部类没有构造函数（因为没有名字） ，也不能被继承 --匿名内部类可以访问外部类的成员：外部类名.this.成员 --匿名内部类如果声明在方法中的话也具有局部内部类的特点， 只能调用 final 的局部 变量 --匿名内部类中不能声明静态的成员 补充： 匿名内部类：没有类名的类 可以访问外部类的成员 声明和实例化一起(声明类型 变量=new 声明类型(){类的定义})； 声明类型：抽象类 接口 普通类 匿名内部类如果定义在方法体里，则具有和局部内部类相同的特征 匿名内部类可以定义在属性的赋值上补充：内部类： 成员内部类：作为一个对象(实例)的成员存在 修饰符可以是 public protected (Default) private abstract final static 可以访问外部类的成员(外部类名.this.成员) 实例化(外部类对象的引用.new 内部类构造函数()) 声明(外部类名.内部类名 变数) 成员内部类里不能定义静态的属性和方法 静态内部类：作为一个类成员存在 修饰符和成员内部类相同 不能访问外部类的非静态成员，可以访问静态成员 实例化(new 外部类名.内部类构造函数()) 声明(外部类名.内部类名 变数) 静态内部类里可以定义静态的属性和方法 局部内部类：定义在方法体里的类3 8修饰符可以是 abstract final 可以访问外部类的成员 声明和实例化跟普通类一样 局部内部类里不能定义静态的属性和方法 局部内部类只能访问 final 修饰的局部变数 匿名内部类：没有类名的类 可以访问外部类的成员 声明和实例化一起(声明类型 变量=new 声明类型(){类的定义})； 声明类型：抽象类 接口 普通类 匿名内部类如果定义在方法体里，则具有和局部内部类相同的特征 匿名内部类可以定义在属性的赋值上内部类的应用： 1.如果一个类需要在多个类中使用，则考虑使用普通公开类 2.如果一个类需要在一个类中多个方法里使用，考虑使用成员内部类 3.如果一个类需要在某个方法里多次使用，考虑使用局部内部类 4.如果一个类需要在某处使用一次，考虑使用匿名内部类3 9CoreJava DAY12 集合 List############################################################################### ############### CoreJava DAY12() ################## ############### Made by MoXiaoMing ################## ############################################################################### AM: 集合很重要，请大家务必学好。4 04 1&&接口&& Map Iterable中只有一个方法public Iterator iterator()，返回类型是Iterator&&接口&& Inerator +hasNext() +next() +remove()HashMap &&接口&& Iterable +iterator() : Inerator&&