Java自学笔记Day11

Day11

包(package)

包的概述及其分类

*A:为什么要有包?
    *将字节码(.class)进行分类存放
    *包其实就是文件夹;
B:包的概述:
	举例:
		学生:增加,删除,修改,查询;
		老师:增加,删除,修改,查询;
		...
           
        方案1:按照功能划分:
			com.heima.add;
				AddStudent;
				AddTeacher;
			com.heima.delete
				DeleteStudent;
				DeleteTeacher;
		方案2:按照模块划分:
			com.heima.teacher
				AddTeacher;
				DeleteTeacher;
				UpdateTeacher;
				FindTeacher;
			com.heima.Student
				AddStudent;
				DeleteStudent;
				UpdateStudent;
				FindStudent;
C:包的命名 :域名倒着写+包的作用(或包的隶属模块);

包的格式及其注意事项

*A:定义包的格式:
	*package 包名;
	*多级包用.隔开即可;
*B:定义包的注意事项:
	*A:package语句必须是程序的第一条可执行语句;
	*B:package语句在一个java文件中只能有一个;
	*C:如果没有package,默认表示无包名;
*C:案例演示
	*包的定义及注意事项
package com.heima;
class Demo1_Package  {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

带包的类编译和运行

*A:如何编译:编译的时候带上-d即可
	javac -d . HelloWorld.java
*B:如何运行:通过java命令执行
	java 包名 .HelloWorld

不同包之下类的访问

package com.heima;
class Demo1_Package  {
	public static void main(String[] args) {
		com.baidu.Person p = new com.baidu.Person("张三",23);
		System.out.println(p.getName() + "---" + p.getAge());
	}
}

import关键字的使用

/*首先要使用的类必须是public修饰的
使用import关键字可以导入其他包中的类 
a.星号方式导入. 导入指定包中所有的类. 如果当前包中有同名的类, 优先使用当前包中的.
b.类名方式导入. 导入指定包中指定的类. 无论当前包中是否有需要的类, 都使用导入的包中的类.
如果一个类中要是用两个包中同名的类, 那么每次使用的时候都加上包名即可*/
//package 必须写下程序可执行的第一条语句,且只能有一个;
import写在class之前即可,可以写好几个;
import com.baidu.Person;
//import java.util.Scanner;	//开发中用的都是导入具体的类
import java.util.*			//*代表通配符,它会到该包下挨个匹配,匹配上就导入;
class Demo1_Package  {
	public static void main(String[] args) {
		Person p = new Person("张三",23);
		System.out.println(p.getName() + "---" + p.getAge());
	}
}

四种权限修饰符

private 私有, 只有当前类可用. 类是不能私有的.
默认, 同包中的类可用. 类默认也是只能同包内使用.
protected 保护, 同包中的类和子类可用. 类不能使用这个修饰符.
public 公有, 所有的类都可用. 如果一个类希望被其他包中的类使用, 那么必须使用* public修饰. public的类必须和文件名一致.

	本类	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private	Y
默认	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

类及其组成所使用的常见修饰符

A:修饰符:
	*权限修饰符:private,默认的,protected,public
	*状态修饰符:static,final
	*抽象修饰符:abstract
B:类
	*权限修饰符:默认修饰符,public;
	*状态修饰符:final
	*抽象修饰符:abstract
	
	*用的最多的就是public
C:成员变量
	*权限修饰符:private,默认的,protected,public;
	*状态修饰符:static,final;
	用的最多的是private
D:构造方法
	*权限修饰符:private,默认的,protected,public
	*用的最多的是public
E:成员方法
	*权限修饰符:private,默认的,protected,public
	*状态修饰符:static,final
	*抽象修饰符:abstract

内部类

内部类概述及其访问特点

/*
*A:内部类概述
*B:内部类访问特点
	*a:内部类可以直接访问外部类的成员,包括私有;
	*b:外部类要访问内部类的成员,必须创建对象;
	*c:外部类名.内部类名 对象名 = 外部类对象.内部对象;
C:案例演示
*/
class InnerClass  {
	public static void main(String[] args) {
		Outer.Inner i = new Outer().new Inner();	 //创建内部对象
		i.method();
	}
} 
class Outer {
    private int num =10;
	class Inner {
		public void method(){
			System.out.println(num);
		}
	}
}

成员内部类私有使用

A：定义,:在一个外部类中有成员变量和成员方法,那么成员内部类就是把整个一个类当成了外部类的成员对待了
B: 访问方式:内部类访问外部类,内部类可以直接访问外部类,包括私有成员,因为内部类拥有外部类的引用是类名.this 
外部类访问内部类,外部类访问外部类的成员,必须要建立内部类的对象 
格式:外部类名.内部类名 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().new Inner();//outer代表外部类,Inner代表内部类
C:存放位置:在外部类里,在外部类的成员方法外.
D:修饰符:final、abstract、public、private、protected和static等,那么被static修饰的就是下面所说的
class Demo2_InnerClass  {
	public static void main(String[] args) {
		//Outer.Inner oi = new Outer().new Inner();
		//oi.method();
		Outer o = new Outer();
		o.print();
	}
}
class Outer {
    private int num =10	;
	private class Inner {
		public void method(){
			System.out.println(num);
		}
	}
	public void print(){
		Inner i = new Inner();
		i.method();
	}
}

静态成员内部类

class Demo1_Innerclass  {
	public static void main(String[] args) {
		Outer.Inner1 oi = new Outer.Inner1();
		//外部类名.内部类名 对象名 = 外部类名.内部类对象;
		oi.method();
		Outer.Inner2.print();
	}
}
class Outer {
	static class Inner1 {
		public void method(){
			System.out.println("method");
		}
	}
	static class Inner2{
		public static void print(){
			System.out.println("print");
		}
	}
}

class Test1_InnerClass  {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}	
//要求:使用已知的变量,在控制台输出30,20,10
//内部类之所以能获取外部类的成员,是因为他能获取到外部类的引用(外部类名.this)
class Outer {
	public int num =10;
	class Inner {
		public int num = 20;
		public void show(){
			int num = 30;
			System.out.println(num);
			System.out.println(this.num);
			System.out.println(Outer.this.num);
		}
	}
}

局部内部类

A：定义,在外部类成员方法中定义的内部类,他更像局部变量
B: 注意: 
	*局部内部类必须使用final修饰;
	*局部内部类在访问他所在方法中的局部变量必须用final修饰为什么?
        因为当调用这个方法时,局部变量如果没有final修饰,他的声明周期和方法的声明周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部变量内部对象还没有马上消失并享用这个局部变量,就没有了,如果final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用;
	但是 jdk1.8取消了这个事情,所以这可以看成一个bug;
class Demo3_InnerClass  {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}
//局部内部类
class Outer {
	public void method(){
		int num = 10 ;
		class Inner {
			public void print(){
				System.out.println(num);
			}
		}
		Inner i = new Inner();
		i.print();
	}
}

匿名内部类

A:匿名内部类
	*就是内部类的简化写法;
B:存在一个类或者接口;
C:格式
	*new 类名或者接口(){
        重写方法;
	}
D:本质是什么呢?
	*是一个继承了该类或者实现了该接口的子类匿名对象
E:案例演示
	*按照要求来一个匿名内部类
class Demo1_NoNameInnerClass  {
	public static void main(String[] args) {
		Outer o  = new Outer();
		o.method();
	}
}
interface Inter {
	public void print();
}
class Outer {
	/*class Inner implements Inter {
		public void print(){
			System.out.println("print");
		}
	} */
	public void method(){
		//Inner i = new Inner();
		//i.print();
		new Inter(){					 //实现Inter接口
			public void print(){
				 System.out.println("print");
			}
		}.print();
	}
}
*匿名内部类重写多个方法调用
*A:案例演示
	*匿名内部类的方法调用
class Demo2_NoNameInnerClass  {
	public static void main(String[] args) {
		Outer o  = new Outer();
		o.method();
	}
}
interface Inter {
	public void show1();
	public void show2();
}
//匿名内部类只针对重写一个方法时候使用
class Outer {
	public void method(){
		/*new Inter(){
			public void show1(){
				System.out.println("show1");
			}
			public void show2(){
				System.out.println("show2");
			}
		}.show1();
		new Inter(){
			public void show1(){
				System.out.println("show1");
			}
			public void show2(){
				System.out.println("show2");
			}
		}.show2(); */
		Inter i = new Inter(){
			public void show1(){
				System.out.println("show1");
			}
			public void show2(){
				System.out.println("show2");
			}
			public void show3(){
				System.out.println("show3");  //匿名内部类不能向下转型,因为没有子类类名
			}
		};
		i.show1();
		i.show2();
	}
}	

匿名内部类在开发中的应用

class Test1_NoNameInnerClass  {
	public static void main(String[] args) {
		//如何调用PersonDemo中的method方法?
		PersonDemo pd = new PersonDemo();
		//pd.method(new Student());
		pd.method(new Person(){		  //匿名内部类当做参数传递,本是把匿名被不累看作一个对象
			public void show(){
				System.out.println("show");
			}
		});
	}
}
abstract class Person {
	public abstract void show();
}
class PersonDemo {
	public void method(Person p){	//Person p = new Student();
		p.show();
	}
}
/*class Student extends Person {
	public void show(){
		System.out.println("show");
	}
} */

匿名内部类面试题

A:面试题
	按照要求,补全代码
//要求控制台输出"HelloWorld"
class Test2_NoNameInnerClass  {
	public static void main(String[] args) {
	//Outer.method().show()   链式编程,每次调用方法后还能继续调用方法,证明调用方法返回的是对象;
		Inter i = Outer.method();
		i.show()
	}
}
interface Inter {
	void show();
}
class Outer {
	public static Inter method(){
		return new Inter(){
		public void show(){
				System.out.println("HelloWorld");
			}
		};
	}
}	

Eclipse的使用

工具的演化

• 记事本
• 高级记事本
• Eclipse
• 工欲善其事，必先利其器。为了提高Java程序的开发效率。现在介绍一下Eclipse。下载:http://www.eclipse.org/ 了解就行。
• Netbeans
• NetBeans 由Sun公司（2009年被甲骨文收购）在2000年创立，它是开放源运动以及开发人员和客户社区的家园，旨在构建世界级的Java IDE。NetBeans当前可以在Solaris、Windows、Linux和Macintosh OS X平台上进行开发，并在SPL(Sun公用许可)范围内使用。

1：Eclipse的介绍

• (1)eclipse的由来
• A：由IBM一个小组开发。投资4千万美元.
• (2)eclipse的特点
• A：完全由Java语言编写的工具。
• B：不需要安装
• C：免费的，eclipse.org
• D：开源的
• E：扩展性非常强
• (3)eclipse和MyEclipse的区别
• A：MyEclipse是基于eclipse加入了一些用于开发Web的插件,并对这些自己开发的插件进行收费。
• B：特点 MyEclipse集成性很好。收费。
• (4)在使用eclipse之前，系统中必须要先有JDK或者JRE。
  • A:因为eclipse就是用Java语言编写的程序，所以需要jvm的解释执行。
  • B：对于高版本的MyEclipse，内部已经集成了JDK。所以安装后，它会用自己的JDK来执行MyEclipse。
• (5)解压eclipse,双击打开,选择工作空间
  • 第一:如果在Use this as the default and do not ask again这句话前面打勾意思就是下次启动的时候会默认选择这个指定好的,不会再有这个提示
  • 第二:如果还想再换工作空间路径,通常有很多人会这样做,就是把eclipse的压缩包再重新解压一下,但是我们还可以这样做
  • Windows–>Preferences–>General–>Startup and Shutdown–>Workerspaces–>Prompt for workspace on startup前面打勾,重启eclipse就可以了
• (6)Eclipse的安装与汉化 重点
  • A：解压即可。
  • B：汉化的方式：
  • 直接解压，并覆盖即可。但是不建议这样做，这样做的，如果我不想汉化，想还原起来就麻烦了。
  • 步骤如下：
  • 在eclipse目录下建立文件夹links
  • 在links下面建立一个文件名字任意。比如 cn.txt(文件名随意起)
  • 在cn.txt中写如下内容(根据你插件包的位置而定)path=D:\china\eclipse
  • 启动或者重新启动eclipse。

2：Eclipse的组成

• 整体叫做视图，每一个小窗口叫做视窗。在eclipse中要想爽一下，必须先有项目(工程)。
• (1)视图，视窗
• (2)视图就是某些视窗的组合。
• A：Java视图
• B：Debug视图
• C：JavaEE视图
• (3)视图还原
• 在视图操作中，我有可能有误操作。这个时候怎么办？
• Window–Reset重置视图

3：Java透视图

• (1)Package Explorer 包资源管理器
• A：该视图中显示当前工作空间中的所有项目以及项目中的文件。但不显示项目下bin目录中的运行文件。
• B：可以直接在该视图中创建项目，包，类，接口等。
• (2)Outline 大纲视窗
• A：该视图中显示当前代码视图中源文件中定义的类或者接口。以及定义的所有成员。
• B：当代码过长时，查找代码中的某一个类或者成员，在该视窗中是最方便的。
• C：在代码中出现多次的名称要同一更改，也可以在该视窗中完成。同时其他代码如果使用了该变量，那么也会一并改变。
• (3)Console 控制台视窗
• A：用于显示程序的运行结果，相当于DOS命令。
• B：如果有多个控制台同时运行。比如：服务器端和客户端。可以通过控制台上的小屏幕按钮进行控制台的切换。
• C：通过点击小方框，进行控制台的强制停止，相当于DOS中的Ctrl+C。
• (4)Hierarchy 层次视窗
• A：用于显示类之间的层次(继承)关系。
• B：在当前类上，按F4就可以切换到该视窗，并查看层次关系。
• 查看原码，当前类上F3，或者Ctrl+鼠标点击

4：对工作空间进行基本配置

• 注意：在工作空间的设置对于该空间中的所有项目都有效。更换了工作空间，需要重新设置。
• (1)配置Java的编译和运行环境版本
• windows–perference-Java
• Compiler 设置成5.0以上，要和运行环境版本一致。
• Installed JREs：可以指定多个jre环境，但是仅有一个是当前执行的。要和编译器一致，或者高于编译器版本。
• 如果采用高版本编译，用低版本jre运行，会出现异常。
• (2)代码视窗加上行号。
• A：首选项–常规–编辑器–文本编辑器
• B：在当前类中，左侧，右键。Show Line Numbers
• (3)调整字体
• windows–perference(首选项)-General(标准)–Appearance(外观)–Color and Fonts(颜色和字体)
• 右边选择Java。编辑即可。
• 字体选择 Courier New 比较标准，个人爱好
• (4)取消悬浮提示
  • 在首选项设置面板中
  • Java–Editor–Hovers。
  • 右边将Combined Hover勾去掉。
  • 这样代码的悬浮框就不会自动出现了。
  • 如果想看提示，将光标悬浮在代码上，按F2即可。
• (5)取消默认注释
• 在首选项设置面板中
• Java–Code Style–Code Templates
• 右边选择Code，将不希望出现默认注释的代码块中的注释去掉。
• (6)类名高亮 可以这样配置在“java”→“enditor”→“syntac”，右边展开“java”→“classes”，勾上“Enable”这个选项，选择自己喜欢的颜色即可。
• (7)preference->general->editors->texteditor selection backgroud color

5：常用的提高开发的操作

• (1)创建面板 定义类和接口，权限，父类已经实现的接口等。
  • syso:然后alt+/就能出现输出语句(回车 到行尾,shift+回车 到下行的行首),如果单独敲回车就是到下行的行首
  • main:然后alt+/就能出主方法
  • 自己也可以定义。
  • 步骤:windows–perference-Java-Editor-Templates–New
• (2)常用的快捷键 (A,E,F必须掌握)

  • A：alt+/ 内容辅助键,补充类或者接口名，帮我们起变量名，new 后面直接提示等。

  • B：ctrl+/ 单行注释，再按一次，取消单行注释

  • C：ctrl+shift+/ 对选中的区域进行多行注释的封装

  • D：ctrl+shift+\ 用于取消多行注释，只要光标在多行注释中即可

  • E：ctrl+shift+o 对使用了其他包中的类或者接口进行自动导入

  • F：ctrl+shift+f 对代码进行格式化

  • G: ctrl + alt + 上键 向上复制当前行或选中行

  • H: ctrl + alt + 下键 向下复制当前行或选中行

  • I：alt+上键 向上移动当前行或者选中行

  • J：alt+下键 向下移动当前行或者选中行

  • K：ctrl+d 删除当前行，或者删除选中行

  • L：ctrl+shift+x 将选中部分的字母大写

  • M：ctrl+shift+y 将选中部分的字母小写

  • N：ctrl+1 光标放在编译中出现红色波浪线提示的内容上，在该快捷键可以获取建议的处理方式

  • Eclipse快捷键大全

    Ctrl+1 快速修复(最经典的快捷键,就不用多说了)
    Ctrl+D: 删除当前行
    Ctrl+Alt+↓ 复制当前行到下一行(复制增加)
    Ctrl+Alt+↑ 复制当前行到上一行(复制增加)
    Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴了)
    Alt+↑ 当前行和上面一行交互位置(同上)
    Alt+← 前一个编辑的页面
    Alt+→ 下一个编辑的页面(当然是针对上面那条来说了)
    Alt+Enter 显示当前选择资源(工程,or 文件 or文件)的属性
    Shift+Enter 在当前行的下一行插入空行(这时鼠标可以在当前行的任一位置,不一定是最后)
    Shift+Ctrl+Enter 在当前行插入空行(原理同上条)
    Ctrl+Q 定位到最后编辑的地方
    Ctrl+L 定位在某行 (对于程序超过100的人就有福音了)
    Ctrl+M 最大化当前的Edit或View (再按则反之)
    Ctrl+/ 注释当前行,再按则取消注释
    Ctrl+O 快速显示 OutLine
    Ctrl+T 快速显示当前类的继承结构
    Ctrl+W 关闭当前Editer
    Ctrl+K 参照选中的Word快速定位到下一个
    Ctrl+E 快速显示当前Editer的下拉列表(如果当前页面没有显示的用黑体表示)
    Ctrl+/(小键盘) 折叠当前类中的所有代码
    Ctrl+×(小键盘) 展开当前类中的所有代码
    Ctrl+Space 代码助手完成一些代码的插入(但一般和输入法有冲突,可以修改输入法的热键,也可以暂用Alt+/来代替)
    Ctrl+Shift+E 显示管理当前打开的所有的View的管理器(可以选择关闭,激活等操作)
    Ctrl+J 正向增量查找(按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在stutes line中显示没有找到了,查一个单词时,特别实用,这个功能Idea两年前就有了)
    Ctrl+Shift+J 反向增量查找(和上条相同,只不过是从后往前查)
    Ctrl+Shift+F4 关闭所有打开的Editer
    Ctrl+Shift+X 把当前选中的文本全部变味小写
    Ctrl+Shift+Y 把当前选中的文本全部变为小写
    Ctrl+Shift+F 格式化当前代码
    Ctrl+Shift+P 定位到对于的匹配符(譬如{}) (从前面定位后面时,光标要在匹配符里面,后面到前面,则反之)

    下面的快捷键是重构里面常用的,本人就自己喜欢且常用的整理一下(注:一般重构的快捷键都是Alt+Shift开头的了)
    Alt+Shift+R 重命名 (是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力)
    Alt+Shift+M 抽取方法 (这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用)
    Alt+Shift+C 修改函数结构(比较实用,有N个函数调用了这个方法,修改一次搞定)
    Alt+Shift+L 抽取本地变量( 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候)
    Alt+Shift+F 把Class中的local变量变为field变量 (比较实用的功能)
    Alt+Shift+I 合并变量(可能这样说有点不妥Inline)
    Alt+Shift+V 移动函数和变量(不怎么常用)
    Alt+Shift+Z 重构的后悔药(Undo)

    编辑
    作用域 功能 快捷键
    全局 查找并替换 Ctrl+F
    文本编辑器 查找上一个 Ctrl+Shift+K
    文本编辑器 查找下一个 Ctrl+K
    全局 撤销 Ctrl+Z
    全局 复制 Ctrl+C
    全局 恢复上一个选择 Alt+Shift+↓
    全局 剪切 Ctrl+X
    全局 快速修正 Ctrl1+1
    全局 内容辅助 Alt+/
    全局 全部选中 Ctrl+A
    全局 删除 Delete
    全局 上下文信息 Alt+？
    Alt+Shift+?
    Ctrl+Shift+Space
    Java编辑器 显示工具提示描述 F2
    Java编辑器 选择封装元素 Alt+Shift+↑
    Java编辑器 选择上一个元素 Alt+Shift+←
    Java编辑器 选择下一个元素 Alt+Shift+→
    文本编辑器 增量查找 Ctrl+J
    文本编辑器 增量逆向查找 Ctrl+Shift+J
    全局 粘贴 Ctrl+V
    全局 重做 Ctrl+Y

    查看
    作用域 功能 快捷键
    全局 放大 Ctrl+=
    全局 缩小 Ctrl±

    窗口
    作用域 功能 快捷键
    全局 激活编辑器 F12
    全局 切换编辑器 Ctrl+Shift+W
    全局 上一个编辑器 Ctrl+Shift+F6
    全局 上一个视图 Ctrl+Shift+F7
    全局 上一个透视图 Ctrl+Shift+F8
    全局 下一个编辑器 Ctrl+F6
    全局 下一个视图 Ctrl+F7
    全局 下一个透视图 Ctrl+F8
    文本编辑器 显示标尺上下文菜单 Ctrl+W
    全局 显示视图菜单 Ctrl+F10
    全局 显示系统菜单 Alt±

    导航
    作用域 功能 快捷键
    Java编辑器 打开结构 Ctrl+F3
    全局 打开类型 Ctrl+Shift+T
    全局 打开类型层次结构 F4
    全局 打开声明 F3
    全局 打开外部javadoc Shift+F2
    全局 打开资源 Ctrl+Shift+R
    全局 后退历史记录 Alt+←
    全局 前进历史记录 Alt+→
    全局 上一个 Ctrl+,
    全局 下一个 Ctrl+.
    Java编辑器 显示大纲 Ctrl+O
    全局 在层次结构中打开类型 Ctrl+Shift+H
    全局 转至匹配的括号 Ctrl+Shift+P
    全局 转至上一个编辑位置 Ctrl+Q
    Java编辑器 转至上一个成员 Ctrl+Shift+↑
    Java编辑器 转至下一个成员 Ctrl+Shift+↓
    文本编辑器 转至行 Ctrl+L

    搜索
    作用域 功能 快捷键
    全局 出现在文件中 Ctrl+Shift+U
    全局 打开搜索对话框 Ctrl+H
    全局 工作区中的声明 Ctrl+G
    全局 工作区中的引用 Ctrl+Shift+G

    文本编辑
    作用域 功能 快捷键
    文本编辑器 改写切换 Insert
    文本编辑器 上滚行 Ctrl+↑
    文本编辑器 下滚行 Ctrl+↓

    文件
    作用域 功能 快捷键
    全局 保存 Ctrl+X
    Ctrl+S
    全局 打印 Ctrl+P
    全局 关闭 Ctrl+F4
    全局 全部保存 Ctrl+Shift+S
    全局 全部关闭 Ctrl+Shift+F4
    全局 属性 Alt+Enter
    全局 新建 Ctrl+N

    项目
    作用域 功能 快捷键
    全局 全部构建 Ctrl+B

    源代码
    作用域 功能 快捷键
    Java编辑器 格式化 Ctrl+Shift+F
    Java编辑器 取消注释 Ctrl+\
    Java编辑器 注释 Ctrl+/
    Java编辑器 添加导入 Ctrl+Shift+M
    Java编辑器 组织导入 Ctrl+Shift+O
    Java编辑器 使用try/catch块来包围 未设置，太常用了，所以在这里列出,建议自己设置。
    也可以使用Ctrl+1自动修正。

    运行
    作用域 功能 快捷键
    全局 单步返回 F7
    全局 单步跳过 F6
    全局 单步跳入 F5
    全局 单步跳入选择 Ctrl+F5
    全局 调试上次启动 F11
    全局 继续 F8
    全局 使用过滤器单步执行 Shift+F5
    全局 添加/去除断点 Ctrl+Shift+B
    全局 显示 Ctrl+D
    全局 运行上次启动 Ctrl+F11
    全局 运行至行 Ctrl+R
    全局 执行 Ctrl+U

    重构
    作用域 功能 快捷键
    全局 撤销重构 Alt+Shift+Z
    全局 抽取方法 Alt+Shift+M
    全局 抽取局部变量 Alt+Shift+L
    全局 内联 Alt+Shift+I
    全局 移动 Alt+Shift+V
    全局 重命名 Alt+Shift+R
    全局 重做 Alt+Shift+Y

6：代码生成的快捷键alt+shift+s

• 出现source
• 1：在区域中右键
• 2：alt+shift+s

(1)私有字段的get/set 重点 (2)构造方法 (3)重写父类方法 重点 @Override 注解 表明此方法是重写父类的.

(4)添加注释 /** 回车 (5)方法的重构 右键–refactor–Extract Method

int sum = a + b;
System.out.println(sum);

选中a+b 扩展可以生成带返回值的。

7：Debug 调试程序

• 注释找错误
• 输出打印调试程序
• 程序不是写出来的,是改出来的.
• (1)让我们调试程序更加方便
• (2)想要调试，需要在程序中加入断点
• (3)运行debug as，打开debug视图
• (4)快捷键
• f5:跳入
• f6:跳过
• f7:跳出
• (5)清除断点
• 在Breakpoints视窗中清除指定断点或者所有断点。

8：打jar包，导入jar包，及jar包的使用。

• 1：打jar包。
• 选中项目–右键–Export–Java–jar–next–自己写jar包的名字和选择路径–finish.
• 2:jar包的使用。
• 导入jar包
• 1:单独添加jar，
• 把jar复制,然后粘贴到项目路径下
• 一定要把jar添加至classpath路径中.
• 怎么添加呢?
• 右键jar包–添加构建路径 项目下：.classpath文件中可以看到
• 如果,这写jar不用了,那么,就从构建路径中把jar包移除.
• 选中项目–右键–首选项–Java Build Path–library–选中其中的jar包,给remove.
• 2:为了方便管理多个jar包。
• 通常建立一个目录，名字建立定义为lib。
• 将jar都存放在该目录下
• 如果要使用jar包，只要将该jar导入到eclipse的classpath路径下。
• 右键至添加构建路径 项目下：.classpath文件中可以看到

9：导入已有的项目

• 空白区域–右键–import–General–Existing Project into Workspace–选中你的项目目录–finish–OK
• 删除项目中有两种。 选中和不选中删除硬盘上的项目.
• 请不要选中删除硬盘上的项目。

10: Object类

• getClass()

• Demo d = new Demo();
  Class clazz1 = d.getClass();                //返回对象的运行时类
  Class clazz2 = Demo.class;
  System.out.println(clazz1 == clazz2);
  

• hashCode()

  Demo d = new Demo();
  int hashCode = d.hashCode();
  System.out.println(hashCode);
  

• toString()

  Demo d = new Demo();
  System.out.println(d);              //当对对象的引用打印时,会默认调用对象的toString方法,如果
  System.out.println(d.toString());   //该对象所属的类中没有toString方法,会调用Object类中(父类)
  
  int[] arr = new int[5];             //数组的父类也是Object
  System.out.println(arr);
  System.out.println(arr.toString());
  

• equals()

• public boolean equals(Object obj) {
  return (this == obj);
  }
  ==号和equals方法的区别
  1,==号是一个符号,比较运算符,equals是一个方法
  2,==号既可以比较基本数据类型,也可以比较引用数据类型,比较基本数据类型比较的是值,比较引用数据类型比较的是地址值
    equals方法在没有重写之前(Object类中的定义的)其实与==比较引用数据类型是一样的,但是我们在自定义类如果想比较对象中
  属性,就需要重写equals方法,其实equals方法主要是用来比较对象的属性
  equals方法只能比较引用数据类型 
  

• finalize()

  class DemoA {
      @Override
      public void finalize(){
          System.out.println("垃圾被清扫了");
      }
  
  }