一只笨鸟的学习笔记
【面向对象】【类】内部类
内部类:定义在另一个类中的类
内部类的好处、存在意义：
·内部类方法可以访问该类定义所在的作用域中的数据，包括私有的数据
·内部类可以对同一个包中的其他类隐藏起来
·当想要定义一个回调函数且不想编写大量代码时，使用匿名（anonymous）内部类比较便捷。
没有更多推荐了，类与对象( 二 )--静态和内部类
这些只是我在这方面所学到的一些皮毛，整理的粗糙，请多指教。
静态成员修饰的成员与一般的成员区别：
一般的成员是每个对象有一份数据，而静态成员是属于类的，即所有对象所共享；
一般成员的访问方式：对象名.成员名；而静态成员的访问方式：类名.成员名。
如下案例：
public class Student {
//公有的就定义成静态的
private S//姓名
//班级人数
public Student(String name, int age) {
this.name =
this.age =
count ++;//每执行一次，人数加一
public void printClassInfo(){
System.out.println("班级人数："+count);
public static void main(String[] args) {
Student s1 = new Student("陈安安",18);
Student s2 = new Student("田娜娜",17);
Student s3 = new Student("小安安",19);
s1.printClassInfo();
s2.printClassInfo();
s3.printClassInfo();
输出结果是：
执行上述代码，创建了三个学生，本来预期输出班纳吉信息人数应为3人，但实际结果是1人，为什么？
因为姓名是每个学生一份，但班级人数不应该是个体属性，而是整体属性。
修改上面代码如下即可：
上面的this是“这个”，“当前”的意思，每个成员方法都隐含一个参数(this)，比如：
System.out.println("学号："+sno);
//严格来讲，应该写成
System.out.println("学号："+this.sno);
对于一般的成员变量，是在构造函数中初始化，那么静态成员变量在哪初始化？能否也在构造函数中初始化呢？
不能，因为每次实例化对象时，都要执行构造函数（可能多次），但静态成员是整个类共享的，只需要初始化一次，所以不能在构造函数中初始化，只能在静态代码块中书写。如下：
* 静态代码块
className = "Java班";
classroom = "5号教室";
count = 0;
静态常量？静态成员变量？静态成员方法？静态代码块？
静态方法没有this，因为静态成员属于整个类，它是共享的，所以没有this，而一般成员每使用一次调用一次。
静态方法中只能访问静态成员。如下图：
静态代码块只调用一次。
一般的成员都是通过哦构造函数去完成初始化（实例化对象时），而静态成员则是在加载类的时候（也就是实例化之前）初始化。
内部类是只在一个类的内部定义的类，内部类可以自由访问外部类的成员，内部类可以作为成员类（在外部类中定义，和成员方法平行）和方法内部类（定义在外部类的成员方法里面）。如下实例：
public class Outter {
private int x = 3;
public class Inner{
private int y = 5;
public void print(){
System.out.printf("内部类成员y="+y);
System.out.printf("外部类成员x="+x);
public static void main(String[] args) {
Outter.Inner inner = new Outter().new Inner();
inner.print();
在什么情况下使用内部类：当一个类离开了另一个类而无法单独存在或者说没有意义的情况下，使用内部类是合适的（比如：cpu离开了计算机，单独存在就没有了意义）。
静态内部类和成员内部类的区别
java基础[1]类与对象_内部类_思维导图总结2
C++面向对象实验二：类与对象
Java中的嵌套类、内部类、静态内部类
Android内存泄漏（非静态内部类创建静态实例造成的内存泄漏）
类与对象 (附答案)
非静态内部类不能有静态声明
【Java语法】java中成员内部类内为什么不允许有任何静态声明搜索
为何Android使用非静态内部类容易造成的泄漏！
没有更多推荐了，Life has no end beyond itself
Eclipse 中的重构功能
Eclipse 中的重构功能使其成为了一个现代的 Java 集成开发环境 (IDE)，而不再是一个普通的文本编辑器。使用重构，您可以轻松更改您的代码，而不必担心对别处造成破坏。有了重构，您可以只关注于所编写代码的功能， 而不必分心去考虑代码的外观如何，因为之后您可以使用重构工具来快捷地将代码变成整洁而高度模块化的代码。本文将向您介绍如何使用 Eclipse 中的一些功能强大的重构函数。
Rename 应该是 Eclipse 中重常用的重构。利用这个重构，可以对变量、类、方法、包、文件夹及几乎任何的 Java 标识符进行重命名。当重命名某标识符时，对该标识符的所有引用也将被重命名。调用 Rename 重构的快捷方式是
Alt+Shift+R。 当在 Eclipse 编辑器中对某标识符调用这个快捷方式时，在此编辑器中会出现一个小对话框，可以在这个对话框中修改这个标识符的名字。在按下
Enter 键时，所有对该标识符的引用也将被相应更改。
使用 Move，可以将一个类从一个包移动到另一个包。这个类被物理地移动到目的包所对应的文件夹中，并且对这个类的所有引用也被更改为指向新的包。
如果将一个类拖放到 Package Explorer 视图中的一个新包中，这个重构将会自动发生。
使用 Extract Local Variable 重构，可以将一个 Java 表达式的结果分配给一个新的本地变量。这个重构的一个用途就是通过将一个复杂的 Java 表达式分成多行来简化该表达式。或者，在编辑代码时，先键入此表达式并使用这种重构自动创建一个新本地变量来指定表达式的结果。当返回值的类型很复杂时， 这个重构将很有用，因为变量的类型是自动生成的。
此重构可以从编辑器调用。在键入想要将其分配给某变量的表达式后，按下 Ctrl+1 并选择 Assign statement to a local variable。这样一个具有适当类型的新变量就创建好了。
Extract Constant 重构可以将代码中的任何数字或字符串文字转换成一个静态终态字段（final field）。在重构后，所有对这个类中的数字或字符串文字的使用都将指向该字段，而不是指向数字或字符串文字本身。这样，在一个位置（字段的值）就可以 实现对所有数字或字符串文字的修改，再也无需在整篇代码中执行查询和替代了。
要使用这个重构，请选择编辑器中的数字或字符串文字，然后按下 Ctrl+1 并选择 Extract to Constant。
正如其名称所示，这个 Convert Local Variable to Field 重构能够获取一个本地变量并将这个变量转换为此类的一个私有字段。此后，所有对这个本地变量的引用也将指向该字段。
要使用这个重构，请选择一个本地变量，然后按下 Ctrl+1 并选择 Convert Local Variable to Field。
Convert Anonymous Class to Nested 重构能够接受一个匿名类并将其转换为最初包含这个匿名类的方法的一个嵌套类。
要使用这个重构，请将光标放入这个匿名类并从菜单中选择 Refactor & Convert Anonymous Class to Nested。这时会出现一个对话 框，要求输入新类的名称。此外，还可以设置类的属性，比如指定对这个类的访问是公共的、受保护的、私有的还是默认的。也可以指定这个类是终态的、静态的还 是两者都是。
例如，清单 1 所示的代码使用一个匿名类创建了一个 Thread Factory。
void createPool() {
threadPool = Executors.newFixedThreadPool(1, new ThreadFactory()
public Thread newThread(Runnable r)
Thread t = new Thread(r);
t.setName("Worker thread");
t.setPriority(Thread.MIN_PRIORITY);
t.setDaemon(true);
如果这个匿名类可被作为一个内部类单独放置，那么清单 1 中的代码将会简洁很多。因此，我执行 Convert Anonymous Class to Nested 重构，并将这个新类命名为
MyThreadFactory。 结果更为简洁，如清单 2 中的代码所示。
private final class MyThreadFactory implements ThreadFactory
public Thread newThread(Runnable r)
Thread t = new Thread(r);
t.setName("Worker thread");
t.setPriority(Thread.MIN_PRIORITY);
t.setDaemon(true);
void createPool(){
threadPool = Executors.newFixedThreadPool(1, new MyThreadFactory());
Convert Member Type to Top Level 重构可以接受一个嵌套类并将其转换为一个包含其自已的 Java 文件的顶级类。
要使用这个重构，请将光标放在一个嵌套类中并选择 Refactor & Convert Member Type to Top Level。如果这个嵌套类是一个静态类，那么就会立即出现一个框，显示这个重构的预览。如果它不是一个静态类，那么需要首先声明保存有 对此嵌套类的父类的引用的那个字段的名称，之后才能看到这个预览框。此外，也可以在这个框中将此字段声明为终态。
Extract Interface 重构可以从一个类的已定义的方法生成一个接口。
要使用这个重构，请从菜单中选择 Refactor & Extract Interface。这时会显示出一个要求输 入新接口名称的对话框。可以复选来自这个类且要在此接口内声明的那些方法。此对话框也允许您将所有对这个类的有效引用转换为对这个接口的引用。请注意：这 个重构只会将对这个类的有效引用转换为新的接口类型。这就意味着：如果没有选择这个类中的某个方法作为接口的一部分并且 Eclipse 检测到有一个对类的引用使用了该方法，那么这个引用将不会被转换成新的接口类型。请记住这一点，不要错误地认为对这个类的所有引用都会被转换为新的接口类
Extract Superclass 重构与前面介绍过的 Extract Interface 重构很相似。只不过 Extract Superclass 重构抽取的是一个超类而不是一个接口。如果这个类已经使用了一个超类，那么新生成的超类将把该类作为它的超类，并会保持类的层次结构。
要使用这个重构，请确保光标位于这个类的方法声明或字段上，然后选择 Refactor & Extract Superclass。一个与 Extract Interface 相似的对话框会出现，可以在这个对话框中给这个新的超类命名并选择要放入这个超类的方法和字段。
抽取超类与抽取接口的最大区别在于放入超类中的方法是被实际移到那里的。所以，如果这些方法中的任何一个方法含有对原始类中的任何字段的引 用，就会得到一个编译错误，因为它们对超类是不可见的。这种情况下，最好的补救办法就是将这些被引用的字段也移到这个超类中。
Extract Method 重构允许您选择一块代码并将其转换为一个方法。Eclipse 会自动地推知方法参数及返回类型。
如果一个方法太大并且您想要把此方法再细分为不同的方法，这个重构将很有用。如果有一段代码在很多方法中反复使用，这个重构也能派上用场。当 选择这些代码块中的某一个代码块进行重构时，Eclipse 将找到出现这个代码块的其他地方，并用一个对这个新方法的调用替代它。
要使用这个重构，请选择编辑器中的一个代码块，然后按下 Alt+Shift+M。这时会出现一个对话框，要求输入这个新方法 的名称及可见性（公开的、私有的、保护的或是默认的）。甚至可以更改参数和返回类型。当重构了新方法内的所选代码块以便恰当使用新方法的参数和返回类型 后，新方法就创建完成了。首先完成重构的那个方法现在包括了一个对新方法的调用。
例如，假设我想要在调用了清单 3 中的 map.get() 后，将代码块移到另外一个方法。
public Object get(Object key)
TimedKey timedKey = new TimedKey(System.currentTimeMillis(), key);
Object object = map.get(timedKey);
if (object != null)
* if this was removed after the 'get' call by the worker thread
* put it back in
map.put(timedKey, object);
要做到这一点，请选择编辑器中的这个代码块并按下 Alt+Shift+M。将这个新方法的名称设置为 putIfNotNull()，Eclipse 会生成清单 4 中的代码，并会自动地计算出正确的参数和返回值。
public Object get(Object key)
TimedKey timedKey = new TimedKey(System.currentTimeMillis(), key);
Object object = map.get(timedKey);
return putIfNotNull(timedKey, object);
private Object putIfNotNull(TimedKey timedKey, Object object)
if (object != null)
* if this was removed after the 'get' call by the worker thread
* put it back in
map.put(timedKey, object);
Inline 重构可以内联 对变量或方法的引用。当使用这个重构后，它会用分配给此变量的值或此方法的实现来分别替代对这个变量或方法的引用。这个重构在下列情形中将对于清理代码十 分有用：
当一个方法只被另一个方法调用一次，并且作为一个代码块更有意义时。与把值分配给不同变量而将表达式分成多行相比较，将一个表达式放在一行上看着更整齐时。要使用这个重构，请将光标放在一个变量或方法上，并按下 Alt+Shift+I。这时会出现一个对话框，要求确认这个重构。 如果重构的是一个方法，那么对话框还会给出一个选项，即在执行完这个重构后一并删除此方法。
例如，清单 5 中的第二行只是将一个表达式的值分配给了 timedKey 变量。
public Object put(Object key, Object value)
TimedKey timedKey = new TimedKey(System.currentTimeMillis(), key);
return map.put(timedKey, value);
清单 6 显示执行了 Inline 重构的代码。请注意，以前的两行代码现在变成了整洁的一行代码。
public Object put(Object key, Object value)
return map.put(new TimedKey(System.currentTimeMillis(), key), value);
利用 Change Method Signature 重构可以更改一个方法签名。同时它还将修改所有对该方法的调用以使用这个新签名。
要使用这个重构，请选择 Refactor & Change Method Signature。这时会出现一个如图 1 所示的对话框，可以在这个对话框中任意地修改这个方法，包括添加或删除参数、更改参数的顺序、更改返回值的类型、添加对此方法声明的例外，甚至更改方法的 名称。
请注意，对这个方法的某些修改，例如添加一个参数或更改一个返回类型，可能会导致重构代码的编译错误，这是因为 Eclipse 并不知道要为这些新参数输入什么。
Infer Generic Type Arguments 重构会自动地为原始形式的那些类推测恰当的泛型类型（generic type）。这个重构通常被用于将 Java 5 以前的代码转换为 Java 5 或更新的代码。
这个重构甚至可以从 Package Explorer 调用。只需右键单击 Package Explorer 中的任何一个项目、包或类，然后选择
Refactor & Infer Generic Type Arguments。
清单 7 中的代码显示了一个可以接受 Generic Type Arguments 的 ConcurrentHashMap。 然而，清单 7 中的代码并不指定类型参数。
private final ConcurrentHashMap map = new ConcurrentHashMap();
在使用了 Infer Generic Type Arguments 重构后，Eclipse 会自动地确定正确的类型参数并生成清单 8 中的代码。
private final ConcurrentHashMap map =
new ConcurrentHashMap();
Migrate JAR File 重构可被用来方便地更新在一个项目构建路径上的 Java Archive (JAR) 文件。要用一个新版本更新构建路径上的 JAR 文件，最常用的方法是：
进入项目的属性并将现存的 JAR 文件从这个构建路径中删除。手动地从其文件夹中删除 JAR 文件。复制新的 JAR 文件，并将其重新命名以便反映其在所有构建脚本中被引用时所用的那个名字。手动地向构建路径添加新的 JAR 文件。然而，用 Migrate JAR File 重构，以上这些工作只需一步就可以完成。要调用这个重构，请选择 Refactor & Migrate Jars。在出现的对话框中，选择新 JAR 文件所在的位置。在下面的树中，从项目中选择需要更新为新版本的 JAR。如果选择了
Replace Jar file contents but preserve existing filename 复选框，那么这个新 JAR 文件将被重命名以匹配旧 JAR 文件的名称，因而不会破坏任何以该名称引用这个 JAR 文件的构建脚本。在任何情况下单击
Finish 时，之前的 JAR 文件都将被删除，同时新的 JAR 文件会被复制到原 JAR 文件所在的位置，并会自动地被添加到这个项目的构建路径，以便项目能够使用这个新的 JAR 文件。
重构脚本可以让您导出并共享重构动作。当打算发布某个库的一个新版本并且人们在使用旧版本会导致错误时，重构脚本就显得很有用了。通过在发布 此库的同时发布一个重构脚本，使用旧版本的人只需将这个脚本应用于其项目，就可以使其代码使用这个新版本的库了。
要创建一个重构脚本，请选择 Refactor & Create Script。这时会出现一个如图 2 所示的窗口，显示了在这个工作区所执行过的所有重构的历史记录。选择需要的那些重构，然后为将要生成的脚本指定一个位置，再单击
Create 生成这个脚本。
要将一个已有的重构脚本应用于工作区，请选择 Refactor & Apply Script。在出现的对话框中选择 脚本的位置。单击
Next 以查看脚本将要执行的那些重构，然后单击 Finish 来应用这些重构。
举个例子，假设在 JAR 文件的版本 2 中，com.A 类被重命名为 com.B。 由于使用 JAR 文件版本 1 的人在其代码中还存在对
com.A 的引用，如果只是简单地升级成新版本的库，无疑会破坏他们现有的代码。不过，现在可以在发布 JAR 文件的同时发布一个重构脚本，它可以自动地将对
com.A 类的引用重命名为对 com.B 的引用，这样人们就可以轻松地升级到 JAR 文件的新版本了。
有了 Eclipse 中各种各样的重构，将丑陋的代码转换成漂亮优美的代码就变得易如反掌。重构脚本可以让您轻松地进行应用程序的升级，而不必担心客户需要花上几小时的时间去 遍览文档以找出代码被破坏的原因。Eclipse 的重构功能确实优于其他的文件编辑器和 IDE。
Eclipse 快速提取一个方法 （重构）
Eclipse 重构功能的使用与重构快捷键
使用Eclipse中提供的Refactor(重构)工具
Eclipse的重构功能介绍
实战Eclipse自动重构
Eclipse重构代码
Eclipse使用技巧总结（四）——代码重构专题
Eclipse重构
Eclipse快捷键Assign to local variable
没有更多推荐了，传智播客 刘意_2015年Java基础视频-深入浅出精华版 笔记(day01~day10)
本笔记是个人笔记+摘录笔记相结合，非完全原创day01win 7系统打开DOS有趣方法：按住shift+右键，单击“在此处打开命令窗口”(注意：在此处可以是任何的文件夹，不一定是桌面)用DOS删除的文件不可以在回收站恢复？！！常用DOS命令d: 回车 盘符切换dir(directory):列出当前目录下的文件以及文件夹md (make directory) : 创建目录（创建文件夹）rd (remove directory): 删除目录（删除文件夹，注意：前提是文件夹必须是空的！！）如果想删除不是空的文件夹（比如删除aaaaa文件夹），可以用命令 rd /s aaaaa(会有删除提示)或者rd /s /q aaaaa(静默删除)cd (change directory)改变指定目录(进入指定目录)cd.. : 退回到上一级目录cd\: 退回到根目录del (delete): 删除文件,删除一堆后缀名一样的文件*.txtexit : 退出dos命令行cls : (clear screen)清屏 第一个程序：HelloWorld案例(掌握) class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld");
} } (1)程序解释：
A:Java程序的最基本单位是类，所以我们要定义一个类。
格式：class 类名
举例：class HelloWorld
B:在类中写内容的时候，用大括号括起来。
C:Java程序要想执行，必须有main方法。
格式：public static void main(String[] args)
D:要指向那些东西呢，也用大括号括起来。
E:你要做什么呢?今天我们仅仅做了一个简单的输出
格式：System.out.println("HelloWorld");
注意：""里面的内容是可以改动的。
(2)Java程序的开发执行流程：
A:编写java源程序(.java)
B:通过javac命令编译生成.class文件
C:通过java命令运行.class文件 常见的问题(掌握) (1)扩展名被隐藏
如何找到：工具--文件夹选项--查看--去除隐藏扩展名的那个勾勾(2)要求文件名称和类名一致。
实际上不这样做也是可以的。
但是，注意：
javac后面跟的是文件名+扩展名
java后面跟的类名不带扩展名 (3)Java语言严格区分大小写，请注意。
还有就是单词不要写错了。 (4)见到非法字符: \65307肯定是中文问题。
写程序要求标点符号必须全部是英文状态。 (5)括号的配对问题。
一般来说，括号都是成对出现的。 (6)遇到
在类 HelloWorld 中找不到主方法, 请将主方法定义为
肯定是主方法的格式问题。path环境变量 path环境变量的作用
保证javac命令可以在任意目录下运行。
同理可以配置qq等day21.java关键字--组成关键字的字母全部小写注意:goto和const作为保留字存在，目前并不使用（在JDK的新版本中可能提升为关键字)2.demo:案例，演示3.Java标识符可以是 英文大小写字母 数字字符 $和_ 注意： A.不能以数字开头 B.不能是Java中的关键字 C.Java语言严格区分大小写 4.常见的命名规则(重点)：见名知意
举例：我要定义一个学生类
class Student {}
包：其实就是文件夹，用于把相同的类名进行区分
单级：liuyi
多级：cn.itcast（解析:cn是一个文件夹，itcast也是一个文件夹，cn文件夹里包含有itcast文件夹）
类或者接口：
一个单词：单词的首字母必须大写
举例：Student,Dog
多个单词：每个单词的首字母必须大写
举例：HelloWorld,StudentName
方法或者变量：
一个单词：单词的首字母小写
举例：main,age
多个单词：从第二个单词开始，每个单词的首字母大写
举例：studentAge,showAllNames()
一个单词：全部大写
多个单词：每个字母都大写，用_隔开
举例：STUDENT_MAX_AGE5.Java中注释的分类及格式
单行注释：//
多行注释：/星 星/
注意：多行不可以嵌套使用，而单行是可以的
文档注释：被javadoc工具解析生成一个说明书用注释写的一个Java案例===========================华丽的分割线=========================================/* 需求:我准备写一个java程序，把“HelloWorld”这句话输出在控制台
分析:A:要写一个java程序，必须定义类
B：把数据能够输出，说明我们的程序是可以独立运行的，而程序要独立运行，必须定义main方法
C:把数据输出在控制台，必须使用输出语句
A:java语言提供了一个关键字:class用来定义类，后面跟的是类名
B：main方法的格式是固定的:
public static void main(String[] args) {
C:输出语句的格式是固定的:
System.out.println("HelloWorld");
"HelloWorld"这个内容是可以改变的*///这是我的HelloWorld案例class HelloWorld { /*
为了程序能够独立运行，定义main方法
main方法是程序的入口
被jvm自动调用 */ public static void main(String[] args) {
//为了把数据显示在控制台，我们就使用了输出语句
System.out.println("HelloWorld"); }}===========================华丽的分割线=============================================6.常量:
在程序执行过程中，其值不发生改变的量。 分类：
A:字面值常量
B：自定义常量（后面讲） 字面值常量
A:字符串常量 用双引号括起来的内容。
B：整数常量 所有的整数
举例：100， 200
C：小数常量 所有的小数
举例：10.23,110.11
D：字符常量 用单引号括起来的内容
举例：‘a’，‘A’，‘0’
错误的：‘ab’
E：布尔常量 比较特殊
举例：true，false
F：空常量 后面讲
举例：null7.Java进制 Java针对整数常量提供了4种表现形式 二进制(jdk7以后有) 八进制 十进制 十六进制8.快速的进制转换法 8421码，是bcd码一种。 它表达的意思是每一个二进制位上的数据对应一个固定的值， 只需要把对应的1位置的数据值给相加，即可得到该二进制对应的十进制的值 二进制 1 1 1 1 1 1 1 1 十进制 128 64 32 16 8 4 2 1 例
二进制到十进制的转换 1010100 = 64 + 16 + 4 = 84； 十进制到二进制的转换 100 = 0b1100100(对照着看，首先100&128,所以第八位为0；然后100&64,第七位为1；接着，100-64=36,36&32,所以第六位为1；然后，36-32=4,4&16,所以第五位为0；然后，4&8,第四位为0；然后，4=4，所以第三位为1； 然后，0&2,第二位为0；然后0&1,第一位为0，总的来说是，去掉首位的0就是1100100，再规范化表示为0b1100100)
第一个程序：HelloWorld案例(掌握) class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld");
} } (1)程序解释：
A:Java程序的最基本单位是类，所以我们要定义一个类。
格式：class 类名
举例：class HelloWorld
B:在类中写内容的时候，用大括号括起来。
C:Java程序要想执行，必须有main方法。
格式：public static void main(String[] args)
D:要指向那些东西呢，也用大括号括起来。
E:你要做什么呢?今天我们仅仅做了一个简单的输出
格式：System.out.println("HelloWorld");
注意：""里面的内容是可以改动的。
(2)Java程序的开发执行流程：
A:编写java源程序(.java)
B:通过javac命令编译生成.class文件
C:通过java命令运行.class文件 常见的问题(掌握) (1)扩展名被隐藏
如何找到：工具--文件夹选项--查看--去除隐藏扩展名的那个勾勾(2)要求文件名称和类名一致。
实际上不这样做也是可以的。
但是，注意：
javac后面跟的是文件名+扩展名
java后面跟的类名不带扩展名 (3)Java语言严格区分大小写，请注意。
还有就是单词不要写错了。 (4)见到非法字符: \65307肯定是中文问题。
写程序要求标点符号必须全部是英文状态。 (5)括号的配对问题。
一般来说，括号都是成对出现的。 (6)遇到
在类 HelloWorld 中找不到主方法, 请将主方法定义为
肯定是主方法的格式问题。path环境变量 path环境变量的作用
保证javac命令可以在任意目录下运行。
同理可以配置qq等day21.java关键字--组成关键字的字母全部小写注意:goto和const作为保留字存在，目前并不使用（在JDK的新版本中可能提升为关键字)2.demo:案例，演示3.Java标识符可以是 英文大小写字母 数字字符 $和_ 注意： A.不能以数字开头 B.不能是Java中的关键字 C.Java语言严格区分大小写 4.常见的命名规则(重点)：见名知意
举例：我要定义一个学生类
class Student {}
包：其实就是文件夹，用于把相同的类名进行区分
单级：liuyi
多级：cn.itcast（解析:cn是一个文件夹，itcast也是一个文件夹，cn文件夹里包含有itcast文件夹）
类或者接口：
一个单词：单词的首字母必须大写
举例：Student,Dog
多个单词：每个单词的首字母必须大写
举例：HelloWorld,StudentName
方法或者变量：
一个单词：单词的首字母小写
举例：main,age
多个单词：从第二个单词开始，每个单词的首字母大写
举例：studentAge,showAllNames()
一个单词：全部大写
多个单词：每个字母都大写，用_隔开
举例：STUDENT_MAX_AGE5.Java中注释的分类及格式
单行注释：//
多行注释：/星 星/
注意：多行不可以嵌套使用，而单行是可以的
文档注释：被javadoc工具解析生成一个说明书用注释写的一个Java案例===========================华丽的分割线=========================================/* 需求:我准备写一个java程序，把“HelloWorld”这句话输出在控制台
分析:A:要写一个java程序，必须定义类
B：把数据能够输出，说明我们的程序是可以独立运行的，而程序要独立运行，必须定义main方法
C:把数据输出在控制台，必须使用输出语句
A:java语言提供了一个关键字:class用来定义类，后面跟的是类名
B：main方法的格式是固定的:
public static void main(String[] args) {
C:输出语句的格式是固定的:
System.out.println("HelloWorld");
"HelloWorld"这个内容是可以改变的*///这是我的HelloWorld案例class HelloWorld { /*
为了程序能够独立运行，定义main方法
main方法是程序的入口
被jvm自动调用 */ public static void main(String[] args) {
//为了把数据显示在控制台，我们就使用了输出语句
System.out.println("HelloWorld"); }}===========================华丽的分割线=============================================6.常量:
在程序执行过程中，其值不发生改变的量。 分类：
A:字面值常量
B：自定义常量（后面讲） 字面值常量
A:字符串常量 用双引号括起来的内容。
B：整数常量 所有的整数
举例：100， 200
C：小数常量 所有的小数
举例：10.23,110.11
D：字符常量 用单引号括起来的内容
举例：‘a’，‘A’，‘0’
错误的：‘ab’
E：布尔常量 比较特殊
举例：true，false
F：空常量 后面讲
举例：null7.Java进制 Java针对整数常量提供了4种表现形式 二进制(jdk7以后有) 八进制 十进制 十六进制8.快速的进制转换法 8421码，是bcd码一种。 它表达的意思是每一个二进制位上的数据对应一个固定的值， 只需要把对应的1位置的数据值给相加，即可得到该二进制对应的十进制的值 二进制 1 1 1 1 1 1 1 1 十进制 128 64 32 16 8 4 2 1 例
二进制到十进制的转换 1010100 = 64 + 16 + 4 = 84； 十进制到二进制的转换 100 = 0b1100100(对照着看，首先100&128,所以第八位为0；然后100&64,第七位为1；接着，100-64=36,36&32,所以第六位为1；然后，36-32=4,4&16,所以第五位为0；然后，4&8,第四位为0；然后，4=4，所以第三位为1； 然后，0&2,第二位为0；然后0&1,第一位为0，总的来说是，去掉首位的0就是1100100，再规范化表示为0b1100100)9.原码反码补码原码：正数的原码最高位是0；负数的原码最高位是1；其他的是数值位。符号位 数值位+7
0 0000111-7
1 0000111反码：正数的反码与原码相同。负数的反码与原码是符号不变，数值位取反(0变1,1变0）+7 0 0000111-7 1 1111000 补码：正数的补码与原码相同负数的补码是在反码的基础上加1.+7 0 0000111-7 1 1111001有符号数据表示法的练习A:已知某数X的原码为B，试求X的补码和反码。符号位 数值位原码: 10110100反码： 11001011补码： 11001100B:已知某数X的补码B，试求其原码。符号位 数值位补码： 11101110反码： 11101101原码： 1001001010.数据类型：Java是一种强类型的语言，针对每一种数据都定义了明确的数据类型。数据类型分类：A:基本数据类型B:引用数据类型(类,接口,数值)基本数据类型:4类8种A:整数 占用字节数byte 1short 2int 4long 8B:浮点数float 4double 8C:字符char 2D:布尔boolean
1注意：整数默认是int类型浮点数默认是double类型。长整型后缀用L或者l标记。建议使用L。例如在Java中，long j =
;System.out.println(j);编译时会报错 错误: 过大的整数: ，因为整数(这里是)默认是int类型解决办法
L;单精度浮点数用F或者f标记。建议使用F。例如在Java中，float f = 12.345;
System.out.println(f);编译时会报错
错误: 不兼容的类型: 从double转换到float可能会有损失解决办法
float f = 12.345F;11.数据类型转换默认转换(从小到大的转换)A:byte,short,char—int—long—float—doubleB:byte,short,char相互之间不转换，他们参与运算首先转换为int类型举例=================================================================byte a = 3;int b = 4;byte c = a +//有问题int d = a +//没有问题=================================================================上述 byte c = a +//有问题如何解决？用强制类型转换12.强制转换：从大的数据类型到小的数据类型。格式：目标数据类型 变量 = (目标数据类型) (被转换的数据);注意：不要随意的去使用强制转换，因为它隐含了精度损失问题。那么，//用强制类型转换改进byte c = (byte) (a + b);System.out.println(c);13.思考题：看看下面两个定义有没有区别呢?float f1 = (float)12.345;float f2 = 12.345f;f1其实是通过一个double类型转换过来的。而f2本身就是一个float类型。(建议用f2的写法)14.面试题A面试题：byte b1=3,b2=4,b;b=b1+b2;b=3+4;哪句是编译失败的呢？为什么呢？答：b = b1 + b2;是有问题的。因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。也就是说。b = b1 + b2; -----这个是类型提升，所有有问题。b1 + b2首先整体提升为int类型(byte,short,char相互之间不转换，他们参与运算首先转换为int类型)，int类型的（b1+b2）赋值给byte类型的b，所以有损失精度的错误。b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。也就是说，编译器把3+4看做一个常量而不是变量的加法运算。所以不报错15.强制转换数据溢出后的结果怎么算(一个实例)byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?//我们可以使用强制类型转换byte b = (byte) 130;//结果是多少呢?System.out.println(b);分析过程：我们要想知道结果是什么，就应该知道是如何进行计算的。而我们又知道计算机中数据的运算都是补码进行的。而要得到补码，首先要计算出数据的二进制。A:获取130这个数据的二进制。00 这是130的原码，也是反码，还是补码。B:做截取操作，截成byte类型的了。 这个结果是补码。C:已知补码求原码。(注意不要漏掉这一步，因为内存中操作的是补码，而我们看到的是补码，所以还要转换成原码)符号位 数值位补码： 10000010反码： 10000001原码： 1111111016.//直接输出一个字符System.out.println('a'); //输出a//输出一个字符和一个整数做加法System.out.println('a'+1); //输出98ASCII码表。记住三个值：'a' 97'A' 65'0' 48注意17.字符串参与运算System.out.println("hello"+'a'+1); //输出helloa1，hello优先与‘a’结合System.out.println('a'+1+"hello"); //输出98hello，‘a’优先与1结合，形成98再与hello结合System.out.println("5+5="+5+5); //输出5+5=55，字符串与数字5先结合System.out.println(5+5+"=5+5"); //输出10=5+5，5+5优先形成10，再与字符串结合 补：‘a’+1有类型提升？？？！day31.在定义Long或者Float类型变量的时候，要加L或者f。
整数默认是int类型，浮点数默认是double。
byte，short在定义的时候，他们接收的其实是一个int类型的值。
这个是自己做了一个数据检测的，如果不再它们的范围内，就报错。
float表示的数据范围比long的范围要大
long：2^63-1
float：3.4*10^38 & 2*10^38 & 2*8^38 = 2*2^3^38 = 2*2^114 & 2^63-12.面试题：Java语言中的字符char可以存储一个中文汉字吗?为什么呢? 可以。因为java语言中的字符占用两个字节。（Java中char占两个字节，C语言中char占一个字节）
Java语言采用的是Unicode编码。3. A:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型 B:/获取的是除法操作的商，%获取的是除法操作的余数========================================================================= System.out.println(x/y); //整数相除只能得到整数
//我就想得到小数，该肿么办呢?
//只需要把操作的数据中任意的一个数据变为浮点数
System.out.println(x*1.0/y);
System.out.println(x%y); //得到的是余数==========================================================================4.++,--运算符的使用//参与运算使用
int a = 3;
int b = 4;
int c = a++;
int d = b--;
System.out.println("a:"+a); //输出为4
System.out.println("b:"+b); //输出为3
System.out.println("c:"+c); //输出为3
System.out.println("d:"+d); //输出为4 5.一个面试题面试题：short s=1;s = s+1; short s=1;s+=1;上面两个代码有没有问题，如果有，那里有问题。class OperatorTest {public static void main(String[] args) {//short s = 1;//s = s + 1;//System.out.println(s);short s = 1;s += 1; //好像是 s = s + 1;System.out.println(s);}}为什么第二个木有问题呢?扩展的赋值运算符其实隐含了一个强制类型转换。s += 1;不是等价于 s = s + 1;而是等价于 s = (s的数据类型)(s + 1);(个人理解)也就是说，s = s + 1中的s + 1包含了加法运算，short类型出现了提升（提升为int类型）而s+=1本身隐含了强制的类型转换6.逻辑运算符：&,|,^,!&&,||特点：逻辑运算符一般用于连接boolean类型的表达式或者值。表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。算术表达式：a + b比较表达式：a == b结论：&逻辑与:有false则false。|逻辑或:有true则true。^逻辑异或:相同为false，不同为true。举例：情侣关系。男男,男女,女男,女女!逻辑非:非false则true，非true则false。特点：偶数个不改变本身。例如int a = 3;int b = 4;int c = 5;//&逻辑与System.out.println((a & b) & (a & c)); //false & false = falseSystem.out.println((a & b) & (a & c)); //false & true = falseSystem.out.println((a & b) & (a & c)); //true & false = falseSystem.out.println((a & b) & (a & c)); //true & true = true7.Java中&&与&&&和&的区别? 同理||和|的区别?A:最终结果一样。B:&&具有短路效果。左边是false，右边不执行。开发中常用的逻辑运算符：&&,||,!示例//boolean b1 = ((x++ == 3) & (y++ == 4));//boolean b1 = ((x++ == 3) && (y++ == 4));//boolean b1 = ((++x == 3) & (y++ == 4));boolean b1 = ((++x == 3) && (y++ == 4));System.out.println("x:"+x);System.out.println("y:"+y);System.out.println(b1);8.位运算符：
要做位运算，首先要把数据转换为二进制。 例子
int a = 3;
int b = 4;
System.out.println(3 & 4);
System.out.println(3 | 4);
System.out.println(3 ^ 4);
System.out.println(~3); 分析：因为是位运算，所以我们必须先把数据换算成二进制。
3的二进制：11
4的二进制：100
&位与运算：有0则0。
-----------------------------------
|位或运算：有1则1。
-----------------------------------
^位异或运算：相同则0，不同则1。
-----------------------------------
~按位取反运算符：0变1，1变0
结果是：-49.^的特点:一个数据位异或两次，该数本身不变。(^指的是异或运算符)例如
int a = 10;
int b = 20;
System.out.println(a ^ b ^ b);//10
System.out.println(a ^ b ^ a);//2010.一道面试题：
请自己实现两个整数变量的交换(默认int类型.) 例如
int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b); 方式1：使用第三方变量(开发中用的)
System.out.println("a:"+a+",b:"+b);
System.out.println("------------");
方式2：用位异或实现(面试用)
左边：a,b,a
右边：a ^ b
b = a ^ //a ^ b ^ b = a
a = a ^ //a ^ b ^ a = b
System.out.println("a:"+a+",b:"+b);
方式3：用变量相加的做法
a = a + //a=30
b = a - //b=10
a = a - //a=20
System.out.println("a:"+a+",b:"+b);
方式4：一句话搞定
b = (a+b) - (a=b); //b=30-20=10,a=20
System.out.println("a:"+a+",b:"+b); 11.&&:左移 左边最高位丢弃，右边补齐0 &&:右移 最高位是0，左边补齐0；最高为是1，左边补齐1 &&&:无符号右移 无论最高位是0还是1，左边补齐0 //&& 把&&左边的数据乘以2的移动次幂
System.out.println(3 && 2); //3*2^2 = 3*4 = 12;
//&& 把&&左边的数据除以2的移动次幂
System.out.println(24 && 2); //24 / 2^2 = 24 / 4 = 6
System.out.println(24 &&& 2);
System.out.println(-24 && 2);
System.out.println(-24 &&& 2); 分析 计算出3的二进制：11
&&的移动： 计算出24的二进制：11000
&&&的移动：
计算出24的二进制：11000
update 日00:27:03
12.&&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。update 日23:13:32
1.switch:表示这是switch选择结构表达式:这个地方的取值是有限定的byte,short,int,charJDK5以后可以是枚举JDK7以后可以是字符串面试题byte可以作为switch的表达式吗?long可以作为switch的表达式吗?String可以作为switch的表达式吗?答：byte可以，long不可以，String在jdk7后可以2.switch要注意break问题例如int a = 2;int b = 3;switch(a){default:b++;case 3:b++;case 4:b++; }switch语句只在遇到break才能停止，否则会一直执行下去3.if语句和switch语句的区别?if语句：A:针对结果是boolean类型的判断B:针对一个范围的判断C:针对几个常量值的判断switch语句：针对几个常量值的判断4.breakbreak:中断的意思使用场景：A:switch语句中B:循环语句中。(循环语句中加入了if判断的情况)注意：离开上面的两个场景，无意义。如何使用呢?A:跳出单层循环B:跳出多层循环要想实现这个效果，就必须知道一个东西。带标签的语句。格式：标签名: 语句带标签的break语句相当于goto语句例子：//跳出单层循环for(int x=0; x&10; x++) {if(x == 3) {}System.out.println("HelloWorld");}//跳出多层循环wc:for(int x=0; x&3; x++) {nc:for(int y=0; y&4; y++) {if(y == 2) {//}System.out.print("*");}System.out.println();}语句跳出两个for循环，而普通的break语句只能跳出内层单循环。5.return:返回A:用于结束方法的；B:一旦遇到return,程序就不会在继续往后执行。day51.方法 方法就是完成特定功能的代码块 在很多语言里面都有函数的定义 函数在Java中被称为方法 参数：
实际参数：就是实际参与运算的。
形式参数；就是方法定义上的，用于接收实际参数的。2.方法调用例子public static void main(String[] args) {
int x = 10;
int y = 20;
//方式1：单独调用
//sum(x,y);
//方式2：输出调用
//System.out.println(sum(x,y));
//System.out.println(30);
//方式3：赋值调用
int result = sum(x,y);
//result在这里可以进行操作
System.out.println(result); }
public static int sum(int a,int b) {
return a + }3.方法重载实例[java]
方法重载：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。方法重载特点：与返回值类型无关，只看方法名和参数列表在调用时，虚拟机通过参数列表的不同来区分同名方法简言之:在同一个类中，方法名相同，参数列表不同，与返回值类型无关。 参数列表不同： A：参数个数不同 B：参数类型不同4.数组数组:存储同一种数据类型的多个元素的容器。定义格式：A:数据类型[] 数组名;B:数据类型 数组名[];举例：A:int[] 定义一个int类型的数组a变量B:int a[]; 定义一个int类型的a数组变量推荐使用第一种格式对数组进行初始化a:动态初始化 只指定长度，由系统给出初始化值b:静态初始化 给出初始化值，由系统决定长度动态初始化的格式：数据类型[] 数组名 = new 数据类型[数组长度];举例：int[] arr = new int[3]; 如何获取数组中的元素呢?通过:数组名[索引]索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1。例子int[] arr = new int[3];//用数组名和编号的配合就可以获取数组中的指定编号的元素。这个编号的专业叫法：索引//通过数组名访问数据的格式是：数组名[索引];System.out.println(arr); //[ 地址值。System.out.println(arr[0]);//0System.out.println(arr[1]);//0System.out.println(arr[2]);//0数组的静态初始化：格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};简化格式：数据类型[] 数组名 = {元素1,元素2,…};举例：int[] arr = new int[]{1,2,3};简化后：int[] arr = {1,2,3};注意事项：不要同时动态和静态进行。如下格式：int[] arr = new int[3]{1,2,3}; //错误5.数组操作的两个常见小问题：ArrayIndexOutOfBoundsException:数组索引越界异常原因：你访问了不存在的索引。例如int[] arr = {1,2,3};System.out.println(arr[3]);NullPointerException:空指针异常原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。例如//引用类型的常量：空常量 nullarr =System.out.println(arr[0]);6.数组逆序例子逆序方式1：[java]
方式2：[java]
7.查找元素对应的索引值基本查找方式1：[java]
方式2(特别注意！)：[java]
day061.二维数组就是元素为一维数组的一个数组。格式1数据类型[][] 变量名 = new 数据类型[m][n];m表示这个二维数组有多少个一维数组n表示每一个一维数组的元素个数 举例：int[][] arr = new int[3][2];定义了一个二维数组arr这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]每个一维数组有2个元素，可以通过arr[m][n]来获取表示获取第m+1个一维数组的第n+1个元素注意：A:以下格式也可以表示二维数组a:数据类型 数组名[][] = new 数据类型[m][n];b:数据类型[] 数组名[] = new 数据类型[m][n];一个实例public static void main(String[] args) {//定义一个二维数组int[][] arr = new int[3][2];//定义了一个二维数组arr//这个二维数组有3个一维数组的元素//每一个一维数组有2个元素//输出二维数组名称System.out.println(arr); //地址值 [[I@175078b//输出二维数组的第一个元素一维数组的名称System.out.println(arr[0]); //地址值 [I@42552cSystem.out.println(arr[1]); //地址值 [I@e5bbd6System.out.println(arr[2]); //地址值 [I@8ee016//输出二维数组的元素System.out.println(arr[0][0]); //0System.out.println(arr[0][1]); //0}二维数组格式1的内存图解
格式2数据类型[][] 数组名 = new 数据类型[m][];m:表示这个二维数组有多少个一维数组。列数没有给出，可以动态的给。这一次是一个变化的列数。举例public static void main(String[] args) {//定义数组int[][] arr = new int[3][];System.out.println(arr); //[[I@175078bSystem.out.println(arr[0]); //nullSystem.out.println(arr[1]); //nullSystem.out.println(arr[2]); //null//动态的为每一个一维数组分配空间arr[0] = new int[2];arr[1] = new int[3];arr[2] = new int[1];System.out.println(arr[0]); //[I@42552cSystem.out.println(arr[1]); //[I@e5bbd6System.out.println(arr[2]); //[I@8ee016System.out.println(arr[0][0]); //0System.out.println(arr[0][1]); //0//ArrayIndexOutOfBoundsException//System.out.println(arr[0][2]); //错误arr[1][0] = 100;arr[1][2] = 200;}
格式1，格式2属于动态初始化 格式3 基本格式：数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};简化版格式：数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};举例：int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};int[][] arr = {{1,2,3},{4,5},{6}}; 举例public static void main(String[] args) {//定义数组int[][] arr = {{1,2,3},{4,5},{6}};System.out.println(arr);System.out.println(arr[0]);System.out.println(arr[1]);System.out.println(arr[2]);System.out.println(arr[0][0]); //1System.out.println(arr[1][0]); //4System.out.println(arr[2][0]); //6System.out.println(arr[0][1]); //2System.out.println(arr[1][1]); //5//越界System.out.println(arr[2][1]); //错误}
2.二维数组的遍历 外循环控制的是二维数组的长度，其实就是一维数组的个数。内循环控制的是一维数组的长度。代码如下 public static void main(String[] args) {//定义一个二维数组int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};//arr[0]就是第一个数组//arr[0] = {1,2,3};for(int x=0; x&arr[0]. x++) {System.out.println(arr[0][x]);}System.out.println("--------------");for(int x=0; x&arr[1]. x++) {System.out.println(arr[1][x]);}System.out.println("--------------");for(int x=0; x&arr[2]. x++) {System.out.println(arr[2][x]);}System.out.println("--------------");//用循环改进for(int x=0; x&3; x++) {for(int y=0; y&arr[x]. y++) {System.out.print(arr[x][y]+" ");}System.out.println();}System.out.println("--------------");//3是我们根据上面的代码得出来的//但是，它不能针对任何的数组都可以这样//其实外面的这个循环的长度就是二维数组的长度for(int x=0; x&arr.length; x++) {for(int y=0; y&arr[x].length; y++) {System.out.print(arr[x][y]+" ");}System.out.println();}System.out.println("--------------");//用方法改进//调用方法printArray2(arr);System.out.println("--------------");//我们再来一个列数是变化的int[][] arr2 = {{1,2,3},{4,5},{6}};printArray2(arr2);}/*需求：遍历二维数组两个明确：返回值类型：void参数列表：int[][] arr*/public static void printArray2(int[][] arr) {for(int x=0; x&arr. x++) {for(int y=0; y&arr[x]. y++) {System.out.print(arr[x][y]+" ");}System.out.println();}}3.二维数组累加求和核心代码//通过遍历就可以得到每一个二维数组的元素。for(int x=0; x&arr. x++){for(int y=0; y&arr[x]. y++){//把元素累加即可。sum += arr[x][y];}} 4.Java参数传递问题Java中的参数传递问题：基本类型：形式参数的改变对实际参数没有影响。引用类型：形式参数的改变直接影响实际参数。 例子public static void main(String[] args) {int a = 10;int b = 20;System.out.println("a:"+a+",b:"+b); //a:10,b:20change(a,b);System.out.println("a:"+a+",b:"+b); //??? a:10,b:20 int[] arr = {1,2,3,4,5}; change(arr);System.out.println(arr[1]); //??? 4} public static void change(int a,int b) { //a=10,b=20System.out.println("a:"+a+",b:"+b); //a:10,b:20a = //a=20b = a + //b=40System.out.println("a:"+a+",b:"+b); //a:20,b:40} public static void change(int[] arr) { //arr={1,2,3,4,5};for(int x=0; x&arr. x++) {if(arr[x]%2==0) {arr[x]*=2;}}//arr={1,4,3,8,5};} 一句话:在Java中，只有值传递，只不过基本类型传递的是基本类型的数据值，而引用类型传递的是地址值 6.面向对象思想面向对象是基于面向过程的编程思想。面向过程：强调的是每一个功能的步骤面向对象：强调的是对象，然后由对象去调用功能2:面向对象的思想特点A:是一种更符合我们思想习惯的思想B:可以将复杂的事情简单化C:将我们从执行者变成了指挥者举例：买电脑：面向过程：我的了解电脑--了解我自己的需求--找对应的参数信息--去中关村买电脑--讨价还价--买回电脑面向对象：我知道我要买电脑 -- 班长去给我买 -- 班长就买回来了洗衣服：面向过程：把衣服脱下--找一个盆--放点洗衣粉--加点水--把衣服扔进去--搓一搓--清洗衣服--拧干--晾起来面向对象：把衣服脱下--打开全自动洗衣机--扔进去--一键即可--晾起来吃饭：面向过程：去超市买菜--摘菜--洗菜--切菜--炒菜--盛起来--吃面向对象：上饭店吃饭，你--服务员(点菜)--厨师(做菜)--服务员(端菜)--吃 3.开发，设计，特征面向对象开发就是不断的创建对象，使用对象，指挥对象做事情。面向对象设计其实就是在管理和维护对象之间的关系。 面向对象特征封装(encapsulation)继承(inheritance)多态(polymorphism)4.面向过程与面向对象举例：把大象装进冰箱 面向过程：动作有哪些呢?A:打开冰箱门B:装进大象C:关闭冰箱门 面向对象：我们怎么才能更符合面向对象思想呢?A:有哪些类呢?B:每个类有哪些东西呢?C:类与类直接的关系是什么呢?把大象装进冰箱的分析? (如何分析有哪些类呢?UML。名词提取法。)A:有哪些类呢?大象冰箱DemoB:每个类有哪些东西呢?大象：进去冰箱：开门关门Demo:main方法C:类与类直接的关系是什么呢?Demo中使用大象和冰箱类的功能。5.现实世界中是如何描述一个事物的呢?举例：学生姓名,年龄,性别...学习,吃饭,睡觉属性：该事物的描述信息行为：该事物能够做什么我们学习编程语言，是为了模拟现实世界的事物的。而我们学习的编程语言Java中最基本的单位是：类。所以，我们就应该把事物通过类来体现出来：由此，我们就得到了现实世界事物和类的对应关系： 事物： 类： 属性 成员变量行为 成员方法类：是一组相关的属性和行为的集合。是一个抽象的概念。对象：是该类事物的具体表现形式。具体存在的个体。 举例：学生：类班长：对象=================================现实世界的事物事物：属性 人的身高，体重等行为 人可以学习，吃饭等 Java中用class描述事物也是如此类:成员变量 就是事物的属性成员方法 就是事物的行为定义类其实就是定义类的成员(成员变量和成员方法) ===========================================================6.在一个java文件中写两个类：一个基本的类，一个测试类。注意：文件名称和测试类名称一致。如何使用呢?创建对象使用。如何创建对象呢?格式：类名 对象名 = new 类名();如何使用成员变量呢?对象名.变量名如何使用成员方法呢?对象名.方法名(...)7……
一个对象的内存图二个对象的内存图
三个对象的内存图
使用类的内容a:创建对象? 格式类名 对象名 = new 类名();b:如何使用成员变量和成员方法呢对象名.成员变量对象名.成员方法() day071.成员变量和局部变量一个实例class Varialbe {//成员变量//int num = 10; //0public void show() {//int num2 = 20; //局部变量//可能尚未初始化变量num2//int num2; //没有默认值int num2 = 20;System.out.println(num2);//int num = 100;System.out.println(num);}} class VariableDemo {public static void main(String[] args) {Varialbe v = new Varialbe();System.out.println(v.num); //访问成员变量v.show(); }}
成员变量和局部变量的区别?A:在类中的位置不同成员变量：在类中方法外局部变量：在方法定义中或者方法声明上B:在内存中的位置不同成员变量：在堆内存局部变量：在栈内存C:生命周期不同成员变量：随着对象的创建而存在，随着对象的消失而消失局部变量：随着方法的调用而存在，随着方法的调用完毕而消失D:初始化值不同成员变量：有默认初始化值局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。注意事项：局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。例如，上面关于num的输出问题 2.形式参数的问题：基本类型：形式参数的改变不影响实际参数(值传递)引用类型：形式参数的改变直接影响实际参数(引用传递)===============================================================================//形式参数是引用类型class Student {public void show() {System.out.println("我爱学习");}} class StudentDemo {//如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();s.show();}} class ArgsTest {public static void main(String[] args) {//形式参数是引用类型的调用//需求：我要调用StudentDemo类中的method()方法StudentDemo sd = new StudentDemo();//创建学生对象Student s = new Student();sd.method(s); //把s的地址给到了这里}}===============================================================================3.匿名对象匿名对象：就是没有名字的对象。匿名对象的应用场景：A:调用方法，仅仅只调用一次的时候。注意：调用多次的时候，不适合。那么，这种匿名调用有什么好处吗?有，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。B:匿名对象可以作为实际参数传递 class Student {public void show() {System.out.println("我爱学习");}} class StudentDemo {public void method(Student s) {s.show();}} class NoNameDemo {public static void main(String[] args) {//带名字的调用Student s = new Student();//虽然也在堆内存里，但是有s地址连接着new Student()，new Student()不会这么快消失(只要s还存在)s.show();s.show();//同一个对象被调用两次System.out.println("--------------");//匿名对象//new Student();//匿名对象调用方法new Student().show();new Student().show(); //这里其实是重新创建了一个新的对象。因为这是在堆内存的，调用完就消失了System.out.println("--------------"); 匿名对象可以作为实际参数传递//匿名对象作为实际参数传递StudentDemo sd = new StudentDemo();//Student ss = new Student();//sd.method(ss); //这里的s是一个实际参数//匿名对象sd.method(new Student());//在来一个new StudentDemo().method(new Student()); 4.private:私有的。可以修饰成员变量和成员方法。注意：被private修饰的成员只能在本类中访问。封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。例子class Student {S//写一个方法对数据进行校验 public void setAge(int a) {if(a & 0 || age & 120) {System.out.println("你给的年龄有问题");}else {age =}}//show()方法,显示所有成员变量值public void show() {System.out.println("姓名："+name);System.out.println("年龄："+age);}} class StudentDemo {public static void main(String[] args) {//创建学生对象Student s = new Student();s.show();System.out.println("--------------");//给成员变量赋值s.name = "林青霞";//s.age = 27;s.setAge(27);s.show();System.out.println("--------------");//给age赋值//s.age = -27; //这个数据是不合理的，加上private后age只能在Student类中使用而不能在StudentDemo中使用//通过方法给值s.setAge(-27);s.show();System.out.println("--------------");}} 5.封装和private的应用：A:把成员变量用private修饰B:提高对应的getXxx()和setXxx()方法 class Student{private S public String getName() {}public void setName(String n) {name =}public int getAge() {}public void setAge(int a) {age =}} //测试类class StudentTest {public static void main(String[] args) {//创建学生对象Student s = new Student();//使用成员变量//错误：被私有修饰了，外界不能直接访问了//System.out.println(s.name+"---"+s.age);System.out.println(s.getName()+"---"+s.getAge());//给成员变量赋值//s.name = "林青霞";//s.age = 27;//通过方法给赋值s.setName("林青霞");s.setAge(27);System.out.println(s.getName()+"---"+s.getAge());}} 6.this关键字this:是当前类的对象引用。简单的记，它就代表当前类的一个对象。注意：谁调用这个方法，在该方法内部的this就代表谁。this的场景：解决局部变量隐藏成员变量 例子===================================================================class Student {private S public String getName() {/*public void setName(String n){name =//不用this关键字的以前用法，但是s的名字不够鲜明于是改为name}*/public void setName(String name) { //name = "林青霞";//name = //变量的使用规则：就近原则//这里是类名，目前还没有说过类似的用法，所以这个是有问题的//这里的调用只能通过对象名//这个对象如果存在，它应该代表的是Student的一个对象。//那么，谁能够代表当前类的对象呢? java就提供了一个关键字 this//Student.name =this.name = name;}} class StudentTest {public static void main(String[] args) {//创建学生对象Student s = new Student();//给成员变量赋值s.setName("林青霞");System.out.println(s.getName());}}==================================================================================this:哪个对象调用那个方法，this就代表那个对象this关键字的内存图解.bmp
7.构造方法构造方法：给对象的数据进行初始化 格式：A:方法名与类名相同B:没有返回值类型，连void都没有C:没有具体的返回值 例子class Student {public Student() {System.out.println("这是构造方法");}} class ConstructDemo {public static void main(String[] args) {//创建对象Student s = new Student();System.out.println(s); //Student@e5bbd6}} 构造方法的注意事项:A:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。例子：class Student{}class ConstructDemo2{public static void main(String[] args){//创建对象Student s = new Student();}}图解反编译前
反编译后通过反编译可知主要是new Student()引发的构造方法Student(反编译中的图解)public 为默认所以上图不显示 B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。(构造方法也可以重载，即带不同参数--默认不带参数)注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法 8.类的组成：成员变量，成员方法今天我们又加入了一个新的成员：构造方法。以后再提类的组成：成员变量构造方法成员方法图解 9.注意：import必须出现在所有的class前面。例如1 import java.util.S
2 class ……
6 class ……
9 } 10.staticstatic的特点：(它可以修饰成员变量，还可以修饰成员方法)A:随着类的加载而加载回想main方法。B:优先于对象存在C:被类的所有对象共享举例：咱们班级的学生应该共用同一个班级编号。其实这个特点也是在告诉我们什么时候使用静态?如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。举例：饮水机(用静态修饰)(饮水机可以多人共享使用)水杯(不能用静态修饰)(水杯只能自己一个人用，原则上不可以共享，每个人都有一个)D:可以通过类名调用其实它本身也可以通过对象名调用。推荐使用类名调用。静态修饰的内容一般我们称其为：与类相关的，类成员静态变量也可以通过类名调用.png class Student { //非静态变量 int num = 10;
//静态变量 static int num2 = 20;} class StudentDemo { public static void main(String[] args) {
Student s = new Student();
System.out.println(s.num);
System.out.println(Student.num2);
System.out.println(s.num2); }} static的内存图解 11.static关键字注意事项A:在静态方法中是没有this关键字的如何理解呢?静态是随着类的加载而加载，this是随着对象的创建而存在。静态比对象先存在。B:静态方法只能访问静态的成员变量和静态的成员方法静态方法：成员变量：只能访问静态变量成员方法：只能访问静态成员方法非静态方法：成员变量：可以是静态的，也可以是非静态的成员方法：可是是静态的成员方法，也可以是非静态的成员方法。简单记：静态只能访问静态。(非静态可以访问一切)例子 1 class Teacher {
2 public int num = 10;
3 public static int num2 = 20;
5 public void show() {
6 System.out.println(num); //语句1，隐含的告诉你访问的是成员变量
7 System.out.println(this.num); //语句2，明确的告诉你访问的是成员变量,与语句1相同效果
8 System.out.println(num2);
10 //function();
11 //function2();
14 public static void method() {
15 //无法从静态上下文中引用非静态 变量 num
16 //System.out.println(num);
17 System.out.println(num2);
19 //无法从静态上下文中引用非静态 方法 function()
20 //function();
21 function2();
24 public void function() {
28 public static void function2() {
33 class TeacherDemo {
34 public static void main(String[] args) {
35 //创建对象
36 Teacher t = new Teacher();
37 t.show();
38 System.out.println("------------");
39 t.method();
12.静态变量和成员变量的区别所属不同静态变量属于类，所以也称为为类变量成员变量属于对象，所以也称为实例变量(对象变量)内存中位置不同静态变量存储于方法区的静态区成员变量存储于堆内存内存出现时间不同静态变量随着类的加载而加载，随着类的消失而消失成员变量随着对象的创建而存在，随着对象的消失而消失调用不同静态变量可以通过类名调用，也可以通过对象调用成员变量只能通过对象名调用13.main方法的格式讲解：public static void main(String[] args) {...}public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。main:是一个常见的方法入口。我见过的语言都是以main作为入口。String[] args:这是一个字符串数组。值去哪里了?这个东西到底有什么用啊?怎么给值啊?这个东西早期是为了接收键盘录入的数据的。格式是：java MainDemo hello world java例子 1 class MainDemo {
2 public static void main(String[] args) {
3 //System.out.println(args); //[Ljava.lang.S@175078b
4 //System.out.println(args.length); //0
5 //System.out.println(args[0]); //ArrayIndexOutOfBoundsException
7 //接收数据后
8 System.out.println(args);
9 System.out.println(args.length);
10 //System.out.println(args[0]);
11 for(int x=0; x&args. x++) {
12 System.out.println(args[x]);
13 }
15 }补充：private是封装的一种表现。思考题：构造方法中可不可以有return语句呢？可以。而是写成这个样子：day081.首先要注意，在同一个文件夹下，类定义在两个文件中和定义在一个文件中其实一样的。2.例子===========================================================================class ArrayTool {//把构造方法私有，外界就不能在创建对象了private ArrayTool(){} public static void printArray(int[] arr) { for(int x=0; x&arr. x++) { if(x == arr.length-1) { System.out.println(arr[x]); }else { System.out.print(arr[x]+", "); } } }}=====================================================class ArrayDemo { public static void main(String[] args) { //定义数组 int[] arr = {28,55,37,46,19}; //需求：遍历数组 /* for(int x=0; x&arr. x++) { if(x == arr.length-1) { System.out.println(arr[x]); }else { System.out.print(arr[x]+", "); } } */ //如果我有多个数组都要进行遍历，那么，代码的重复度就很高 //如何改进呢?用方法改进 //调用 //静态方法 //printArray(arr); //非静态方法 //ArrayDemo ad = new ArrayDemo(); //ad.printArray(arr); //测试类的作用：创建其他类的对象，调用其他类的功能。 //而我们现在的操作是跟数组相关的，所以，你应该把这些操作定义到数组操作类中 //定义一个数组的操作类 //有了数组操作类之后的调用 //ArrayTool at = new ArrayTool(); //at.printArray(arr); //方法改进为静态后，就可以直接通过类名调用 ArrayTool.printArray(arr); } /* public static void printArray(int[] arr) { for(int x=0; x&arr. x++) { if(x == arr.length-1) { System.out.println(arr[x]); }else { System.out.print(arr[x]+", "); } } } */ //假设该方法不是静态的 /* public void printArray(int[] arr) { for(int x=0; x&arr. x++) { if(x == arr.length-1) { System.out.println(arr[x]); }else { System.out.print(arr[x]+", "); } } } */ }=======================================================================3.制作文档注释，文档说明书注意：如何制作一个说明书呢?A:写一个工具类B:对这个类加入文档注释怎么加呢?加些什么东西呢?C:用工具解析文档注释javadoc工具D:格式javadoc -d 目录 -author -version ArrayTool.java目录：就可以写一个文件夹的路径制作帮助文档出错：找不到可以文档化的公共或受保护的类：告诉我们类的权限不够(解决办法：在class前面加public)实例=================================================================================/*** 这是针对数组进行操作的工具类* @author 刘意* @version V.10*/public class ArrayTool {//把构造方法私有，外界就不能在创建对象了/*** 这是私有构造*/ private ArrayTool(){}/*** 这是遍历数组的方法，遍历后的格式是：[元素1, 元素2, 元素3, ...]* @param arr 这是要被遍历的数组*/public static void printArray(int[] arr) { System.out.print("["); for(int x=0; x&arr. x++) { if(x == arr.length-1) { System.out.println(arr[x]+"]"); }else { System.out.print(arr[x]+", "); } }}/*** 这是获取数组中最大值的方法* @param arr 这是要获取最大值的数组* @return 返回数组中的最大值*/public static int getMax(int[] arr) { int max = arr[0]; for(int x=1; x&arr. x++) { if(arr[x] & max) { max = arr[x]; } } }/*** 获取指定元素在数组中第一次出现的索引，如果元素不存在，就返回-1* @param arr 被查找的数组 * @param value 要查找的元素* @return 返回元素在数组中的索引，如果不存在，返回-1*/public static int getIndex(int[] arr,int value) { int index = -1; for(int x=0; x&arr. x++) { if(arr[x] == value) { index = } } }}==========================================================================================4.如何查看API帮助文档1:打开帮助文档2:点击显示，找到索引，看到输入框3:知道你要找谁?以Scanner举例4:在输入框里面输入Scanner，然后回车5:看包java.lang包下的类不需要导入，其他的全部需要导入。要导入：java.util.Scanner6:再简单的看看类的解释和说明，别忘了看看该类的版本7:看类的结构成员变量 字段摘要 构造方法 构造方法摘要 成员方法 方法摘要8:学习构造方法 A:有构造方法 就创建对象B:没有构造方法 成员可能都是静态的9:看成员方法A:左边是否静态：如果静态，可以通过类名调用返回值类型：人家返回什么，你就用什么接收。B:右边看方法名：方法名称不要写错参数列表：人家要什么，你就给什么；人家要几个，你就给几个实例MathMath:类包含用于执行基本数学运算的方法由于Math类在java.lang包下，所以不需要导包。特点：没有构造方法，因为它的成员全部是静态的。掌握一个方法：获取随机数public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。===========================================class MathDemo { public static void main(String[] args) { //获取一个随机数 //double d = Math.random(); //System.out.println(d); //需求：我要获取一个1-100之间的随机数，肿么办? for(int x=0; x&100; x++) { int number = (int)(Math.random()*100)+1; System.out.println(number); } }}========================实例2
猜数字小游戏(1-100)
import java.util.S
class GuessNumber
public static void main(String[] args)
//程序产生一个随机数
int number = (int)(Math.random()*100)+1;
//给出多次猜的机会，猜中就结束
while(true)
//键盘录入数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要猜的数据(1-100):");
int guessNumber = sc.nextInt();
if(guessNumber&number)
System.out.println("你要猜的数据"+guessNumber+"大了");
else if(guessNumber&number)
System.out.println("你要猜的数据"+guessNumber+"小了");
System.out.println("恭喜你，猜中了");
} 5.代码块局部代码块：局部位置，用于限定变量的生命周期 实例[java]
构造代码块：在类中的成员位置，用{}括起来的代码
特点：每次调用构造方法执行前，都会先执行构造代码块。
作用：可以把多个构造方法中的共同代码放到一起。class Code{ //构造代码块 {
//注意这一段外面不加大括号会报错，加大括号后就不报错
int x = 100;
System.out.println(x); }
public Code() {
System.out.println("code");//这个打印语句在第三个也就是最后一个才输出 }
int y = 200;
System.out.println(y); }} class CodeDemo{ public static void main(String[] args) {
Code c = new Code();//每一次调用构造方法，都会先执行构造代码块，然后才执行构造方法里面的内容 }}
静态代码块：在类中的成员位置用{}括起来的代码。只不过它用static修饰了
作用：一般是对类进行初始化(随着类的加载而加载)class Code{ //静态代码块 static { int a = 1000; System.out.println(a); }
//构造代码块 {
int x = 10;
System.out.println(x); }
//静态代码块 static {
int b = 2000;
System.out.println(b);//执行顺序是：先打印a(1000),再打印b(2000),最后才打印x(10) }}
由上图可以知道，1000只打印了一次，说明静态代码块只执行一次。 面试题： 静态代码块，构造代码块，构造方法的执行顺序？ 静态代码块 --- 构造代码块 --- 构造方法 而且：静态代码块：只执行一次
构造代码块：每次调用构造方法都执行
由上图可知静态代码块只执行一次，第二次new Student()的时候不打印静态代码块 6.继承 extend 好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类之间产生了关系，是多态的前提
类与类产生了关系，其实也是继承的一个弊端： 类的耦合性增强了。
开发的原则：低耦合，高内聚。
耦合：类与类的关系
内聚：就是自己完成某件事情的能力 注意：Java不支持多继承，但支持多层继承 Java中继承的特点：
A:Java只支持单继承，不支持多继承。
有些语言是支持多继承，格式：extends 类1,类2,...
B:Java支持多层继承(继承体系)
class Father {} class Mother {} class Son exnteds Father {} //正确的 class Son extends Father,Mother {} // 错误的
Java支持多层继承(继承体系) class A{} class B extends A{} class C extends B{} 并且子类可以直接使用父类的父类的方法
例子 class GrandFather { public void show() {
System.out.println("我是爷爷"); }} class Father extends GrandFather { public void method(){
System.out.println("我是老子"); }} class Son extends Father {} class ExtendsDemo2 { public static void main(String[] args) {
Son s = new Son(); s.method(); //使用父亲的 s.show(); //使用爷爷的 }} 7.继承的注意事项： A:子类只能继承父类所有非私有的成员(成员方法和成员变量)(也就是说，父类带private的方法，变量都不可以访问) B:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。 C:不要为了部分功能而去继承 什么时候考虑使用继承呢?
继承其实体现的是一种关系："is a"。
采用假设法。
如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。 8.类的组成：
成员变量：
构造方法：
成员方法： 类的组成部分的各自关系。
继承中成员变量的关系:
A:子类中的成员变量和父类中的成员变量名称不一样
B:子类中的成员变量和父类中的成员变量名称一样
在子类方法中访问一个变量的查找顺序：
a:在子类方法的局部范围找，有就使用
b:在子类的成员范围找，有就使用
c:在父类的成员范围找，有就使用
d:如果还找不到，就报错。示例程序[java]
好了，问题来了，我不仅仅要输出局部范围的num，还要输出本类成员范围的num。怎么办呢?(用this)办法(修改于上一个程序)public void show() {
int num = 30;
System.out.println(num);//就近原则num=30
System.out.println(this.num);//本类中的num=20 }如果还想要输出父类成员范围的num。怎么办呢super关键字 public void show() {
int num = 30;
System.out.println(num);//30
System.out.println(super.num);//父类num=10 } 总结public void show() {
int num = 30;
System.out.println(num);//局部num
System.out.println(this.num);//本类num
System.out.println(super.num);//父类num } 9.this和super的区别this代表本类对应的引用。super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员) 怎么用呢? A:调用成员变量
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量 B:调用构造方法
this(...) 调用本类的构造方法
super(...) 调用父类的构造方法 C:调用成员方法
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法 10.继承中构造方法的关系 A:子类中所有的构造方法默认都会访问父类中空参数的构造方法
B:为什么呢?
因为子类会继承父类中的数据，可能还会使用父类的数据。
所以，子类初始化之前，一定要先完成父类数据的初始化。
注意：子类每一个构造方法的第一条语句默认都是：super();如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?报错。如何解决呢? A:在父类中加一个无参构造方法B:通过使用super关键字去显示的调用父类的带参构造方法C:子类通过this去调用本类的其他构造方法子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。注意事项：this(...)或者super(...)必须出现在第一条语句上。如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。(第一条语句给不给它都默认有一个空的super语句,最好手动说明以免引起冲突)11.一个类的初始化过程成员变量进行初始化默认初始化显示初始化构造方法初始化看程序写结果A:一个类的静态代码块,构造代码块,构造方法的执行流程静态代码块 & 构造代码块 & 构造方法B:静态的内容是随着类的加载而加载静态代码块的内容会优先执行C:子类初始化之前先会进行父类的初始化运行结果是：静态代码块Fu静态代码块Zi构造代码块Fu构造方法Fu构造代码块Zi构造方法Zi*/[java]
12. A:成员变量的问题int x = 10; //成员变量是基本类型Student s = new Student(); //成员变量是引用类型B:一个类的初始化过程成员变量的初始化默认初始化显示初始化构造方法初始化C:子父类的初始化(分层初始化)先进行父类初始化，然后进行子类初始化。结果：YXYZ问题：虽然子类中构造方法默认有一个super()初始化的时候，不是按照那个顺序进行的。而是按照分层初始化进行的。它仅仅表示要先初始化父类数据，再初始化子类数据。例子[java]
13.方法重写：子类中出现了和父类中方法声明一模一样的方法。方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值无子类对象调用方法的时候：先找子类本身，再找父类。方法重写的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。例子A:定义一个手机类。B:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。class Phone {public void call(String name) {System.out.println("给"+name+"打电话");}}class NewPhone extends Phone {public void call(String name) {//System.out.println("给"+name+"打电话");super.call(name); //避免重复代码System.out.println("可以听天气预报了");}}class ExtendsDemo9 {public static void main(String[] args) {NewPhone np = new NewPhone();np.call("林青霞");}}14.方法重写的注意事项A:父类中私有方法不能被重写因为父类私有方法子类根本就无法继承B:子类重写父类方法时，访问权限不能更低(public 高)最好就一致C:父类静态方法，子类也必须通过静态方法进行重写其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中讲解子类重写父类方法的时候，最好声明一模一样。15.两个面试题1：方法重写和方法重载的区别?方法重载能改变返回值类型吗?方法重写：在子类中，出现和父类中一模一样的方法声明的现象。方法重载：同一个类中，出现的方法名相同，参数列表不同的现象。方法重载能改变返回值类型，因为它和返回值类型无关。Override：方法重写Overload：方法重载2：this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。this:代表当前类的对象引用super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)场景：成员变量：this.成员变量super.成员变量构造方法：this(...)super(...)成员方法：this.成员方法super.成员方法16.super实例//定义人类class Person {//姓名private S//年龄public Person() {}public Person(String name,int age) { //"林青霞",27this.name =this.age =}public String getName() {}public void setName(String name) {this.name =}public int getAge() {}public void setAge(int age) {this.age =}}//定义学生类class Student extends Person {public Student() {}public Student(String name,int age) { //"林青霞",27//this.name =//this.age =super(name,age);}}class ExtendsTest4 {public static void main(String[] args) {//创建学生对象并测试//方式1Student s1 = new Student();s1.setName("林青霞");s1.setAge(27);System.out.println(s1.getName()+"---"+s1.getAge());//方式2Student s2 = new Student("林青霞",27);System.out.println(s2.getName()+"---"+s2.getAge());}补充笔记API(Application Programming Interface)应用程序编程接口(帮助文档)day091.final引入继承的代码体现由于继承中方法有一个现象：方法重写。所以，父类的功能，就会被子类给覆盖调。有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。这个时候，针对这种情况，Java就提供了一个关键字：finalfinal:最终的意思。常见的是它可以修饰类，方法，变量。2.finalfinal可以修饰类，方法，变量特点：final可以修饰类，该类不能被继承。final可以修饰方法，该方法不能被重写。(覆盖，复写)final可以修饰变量，该变量不能被重新赋值。因为这个变量其实常量。常量：A:字面值常量"hello",10,trueB:自定义常量final int x = 10;3.final面试题4.final修饰变量的初始化时机A:被final修饰的变量只能赋值一次。B:在构造方法完毕前。(非静态的常量)5.多态多态概
