你需要的是什么，直接评论留言。
分享是一种美德，分享更快乐！
1:eclipse的概述使用(掌握)
1:eclipse的安装
2:用eclipse写一个helloworld案例，最终在控制台输出你的名字
a:创建项目
b:在src目录下创建包。cn.itcast
c:在cn.itcast包下创建类。helloworld
d:在helloworld下有一个方法。public static void main(string[] args) {}
e:在main方法中有一个输出语句。system.out.println("你的名字");
3:eclipse空间的基本配置
a:程序的编译和运行的环境配置(一般不改)
window -- preferences -- java
编译环境：compiler
默认选中的就是最高版本。
运行环境：installed jres
默认会找你安装的那个jdk。建议配置了java的环境变量。
问题：
低编译，高运行。可以。
高编译，低运行。不可以。
建议，编译和运行的版本一致。
b:如何去掉默认注释?
window -- preferences -- java -- code style -- code templates
选择你不想要的内容，通过右边edit编辑。
注意：请只删除注释部分，不是注释部分的不要删除。
c:行号的显示和隐藏
显示：在代码区域的最左边的空白区域，右键 -- show line numbers即可。
隐藏：把上面的动作再做一次。
d:字体大小及颜色
a:java代码区域的字体大小和颜色：
window -- preferences -- general -- appearance -- colors and fonts -- java修改 -- java edit text font
b:控制台
window -- preferences -- general -- appearance -- colors and fonts -- debug -- console font
c:其他文件
window -- preferences -- general -- appearance -- colors and fonts -- basic -- text font
e:窗体给弄乱了，怎么办?
window -- reset perspective
f:控制台找不到了，怎么办?
window--show view—console
4:常用快捷键
a:格式化 ctrl+shift+f
b:导入包 ctrl+shift+o
如果该类仅仅在一个包中有，就自己显示了
如果该类在多个包中有，会弹出一个框框供你选择
c:注释
单行：注释 ctrl+/，取消注释再来一次。
多行：ctrl+shift+/,ctrl+shift+\
d:代码上下移动
选中代码alt+上/下箭头
e:查看源码
选中类名(f3或者ctrl+鼠标点击)
5:如何提高开发效率
a:自动生成构造方法
a:无参构造方法 在代码区域右键--source--generate constructors from superclass
b:带参构造方法 在代码区域右键--source--generate constructors using fields.. -- finish
b:自动生成getxxx()/setxxx()方法
在代码区域右键--source--generate getters and setters...
提供了对应的快捷键操作。
alt+shift+s
按下带有下划线的那个字母即可。
c:如何继承抽象类和实现接口。
d:override的作用
表示该方法是重写父类的。如果方法声明和父类不匹配，就会报错。
6:通过讲解的快捷键和提高开发效率的一些内容完成如下内容
自定义学生类:student
成员变量；
姓名
年龄
构造方法：
无参
带参
成员方法：
getxxx()/setxxx()
在给出一个show()方法，显示类的所有成员信息。
然后，写一个测试类，对学生的代码进行测试。
studentdemo
package cn.itcast_01;
public class student {
// 姓名
private string name;
// 年龄
private int age;
public student(string name, int age) {
super();
this.name = name;
this.age = age;
}
public student() {
public string getname() {
return name;
public void setname(string name) {
public int getage() {
return age;
public void setage(int age) {
public void show() {
system.out.println("姓名：" + name + ",年龄:" + age);
/*
* 测试类
*/
public class studentdemo {
public static void main(string[] args) {
// 创建对象
student s1 = new student();
s1.setname("风清扬");
s1.setage(30);
system.out.println(s1.getname() + "---" + s1.getage());
s1.show();
student s2 = new student("林青霞", 27);
system.out.println(s2.getname() + "---" + s2.getage());
s2.show();
7:删除项目和导入项目
删除项目
选中项目 – 右键 – 删除
从项目区域中删除
从硬盘上删除
导入项目
在项目区域右键找到import
找到general，展开，并找到
existing projects into workspace
点击next,然后选择你要导入的项目
注意：这里选择的是项目名称
8:要注意的几个小问题
如何查看项目所在路径
选中 -- 右键 -- properties -- resource -- location
导入项目要注意的问题
项目区域中不可能出现同名的项目(新建或者导入)
自己随意建立的文件夹是不能作为项目导入的
修改项目问题
不要随意修改项目名称
如果真要修改，不要忘记了配置文件.project中的
<name>把这里改为你改后的名称</name>
9:大家接收文件的注意事项
a:专门建立一个文件夹用于接收项目，不要随意放置。
b:同一个项目再次接收的时候，先去存放目录把原始项目删除，然后重新存储，最后刷新项目即可。
c:每天对照我写的项目，自己也创建一个练习项目
举例：我的项目名称 day11_eclipse
你就创建一个项目名称 day11_eclipse_test
10:eclipse中代码的高级(debug)调试
作用：
调试程序
查看程序执行流程
如何查看程序执行流程
要想看程序流程，就必须设置断点。
什么是断点：
就是一个标记，从哪里开始。
如何设置断点：
你想看哪里的程序，你就在那个有效程序的左边双击即可。
在哪里设置断点：
哪里不会点哪里。
目前：我们就在每个方法的第一条有效语句上都加。
如何运行设置断点后的程序：
右键 -- debug as -- java application
看哪些地方：
debug：断点测试的地方
在这个地方，记住f6，或者点击也可以。一次看一行的执行过程。
variables：查看程序的变量变化
fordemo：被查看的源文件
console：控制台
如何去断点：
a:再次双击即可
b:找到debug视图，variables界面，找到breakpoints，并点击，然后看到所有的断点，最后点击那个双叉。
package cn.itcast_03;
* 通过debug查看程序执行流程
* 请大家也做一遍。
public class argsdemo {
int a = 10;
int b = 20;
system.out.println("a:" + a + ",b:" + b);
change(a, b);
int[] arr = { 1, 2, 3, 4, 5 };
change(arr);
system.out.println(arr[1]);
public static void change(int a, int b) {
a = b;
b = a + b;
public static void change(int[] arr) {
for (int x = 0; x < arr.length; x++) {
if (arr[x] % 2 == 0) {
arr[x] *= 2;
public class fordemo {
// 定义求和变量
int sum = 0;
for (int x = 1; x < 6; x++) {
sum += x;
system.out.println("sum:" + sum);
2:api的概述(了解)
(1)应用程序编程接口。
(2)就是jdk提供给我们的一些提高编程效率的java类。
3:object类(掌握)
(1)object是类层次结构的根类，所有的类都直接或者间接的继承自object类。
(2)object类的构造方法有一个，并且是无参构造
这其实就是理解当时我们说过，子类构造方法默认访问父类的构造是无参构造
(3)要掌握的方法：
a:tostring()
返回对象的字符串表示，默认是由类的全路径+'@'+哈希值的十六进制表示。
这个表示其实是没有意义的，一般子类都会重写该方法。
如何重写呢?过程我也讲解过了，基本上就是要求信息简单明了。
但是最终还是自动生成。
package cn.itcast_02;
@override
public string tostring() {
return "student [name=" + name + ", age=" + age + "]";
// @override
// public string tostring() {
// // return super.tostring();
// // return "hello";
// return "姓名:" + name + ",年龄:" + age;
// }
* public string tostring():返回该对象的字符串表示。
*
* integer类下的一个静态方法：
public static string tohexstring(int i)：把一个整数转成一个十六进制表示的字符串
* 这个信息的组成我们讲解完毕了，但是这个信息是没有任何意义的。所以，建议所有子类都重写该方法。
* 怎么重写呢?
把该类的所有成员变量值组成返回即可。
* 重写的最终版方案就是自动生成tostring()方法。
* 注意：
直接输出一个对象的名称，其实就是调用该对象的tostring()方法。
student s = new student();
system.out.println(s.hashcode());
system.out.println(s.getclass().getname());
system.out.println("--------------------");
system.out.println(s.tostring());// cn.itcast_02.student@42552c
// tostring()方法的值等价于它
// getclass().getname() + '@' + integer.tohexstring(hashcode())
// this.getclass().getname()+'@'+integer.tohexstring(this.hashcode())
// cn.itcast_02.student@42552c
system.out.println(s.getclass().getname() + '@'
+ integer.tohexstring(s.hashcode()));
system.out.println(s.tostring());
// 直接输出对象的名称
system.out.println(s);
b:equals()
比较两个对象是否相同。默认情况下，比较的是地址值是否相同。
而比较地址值是没有意义的，所以，一般子类也会重写该方法。
重写过程，我也详细的讲解和分析了。
public boolean equals(object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getclass() != obj.getclass())
student other = (student) obj;
if (age != other.age)
if (name == null) {
if (other.name != null)
} else if (!name.equals(other.name))
//
// return true;
//这里要改进，根据这里比较的成员变量来决定返回true还是false
//这里其实要比价的就是name和age
//但是，name是string类型的，而string是引用类型的，所以，在这里不能直接用==比较，应该用equals()比较
//string的equals()方法是重写自object类的，比较的是字符串的内容是否相同
//this -- s1
//obj -- s2
//我们要使用的是学生类的特有成员变量,所以要向下转型
student s = (student)obj; //s -- obj -- s2;
if(this.name.equals(s.name) && this.age == s.age) {
}else {
//为了提高效率
if(this == obj){
//为了提供程序的健壮性
//我先判断一下，obj是不是学生的一个对象，如果是，再做向下转型，如果不是，直接返回false。
//这个时候，我们要判断的是对象是否是某个类的对象?
//记住一个格式：对象名 instanceof 类名
//表示：判断该对象名是否是该类名一个对象
if(!(obj instanceof student)){
//如果是就继续
student s = (student)obj;
//system.out.println("同一个对象，还需要向下转型并比较吗?");
return this.name.equals(s.name) && this.age == s.age;
* public boolean equals(object obj):指示其他某个对象是否与此对象“相等”。
* 这个方法，默认情况下比较的是地址值。比较地址值一般来说意义不大，所以我们要重写该方法。
一般都是用来比较对象的成员变量值是否相同。
* 重写的代码优化：提高效率，提高程序的健壮性。
* 最终版：
其实还是自动生成。
* 看源码：
//this - s1
//obj - s2
*
return (this == obj);
*
* ==:
基本类型：比较的就是值是否相同
引用类型：比较的就是地址值是否相同
* equals:
引用类型：默认情况下，比较的是地址值。
不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同
student s1 = new student("林青霞", 27);
system.out.println(s1 == s2); // false
student s3 = s1;
system.out.println(s1 == s3);// true
system.out.println("---------------");
system.out.println(s1.equals(s2)); // obj = s2; //false
system.out.println(s1.equals(s1)); // true
system.out.println(s1.equals(s3)); // true
student s4 = new student("风清扬",30);
system.out.println(s1.equals(s4)); //false
demo d = new demo();
system.out.println(s1.equals(d)); //classcastexception
class demo {}
(4)要了解的方法：
a:hashcode() 返回对象的哈希值。不是实际地址值，可以理解为地址值。
b:getclass() 返回对象的字节码文件对象，反射中我们会详细讲解
c:finalize() 用于垃圾回收，在不确定的时间
d:clone() 可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指向同一个对象是有区别的。
package cn.itcast_04;
public class student implements cloneable {
protected object clone() throws clonenotsupportedexception {
return super.clone();
* object:类 object 是类层次结构的根类。每个类都使用 object 作为超类。
* 每个类都直接或者间接的继承自object类。
* object类的方法：
public int hashcode():返回该对象的哈希码值。
注意：哈希值是根据哈希算法计算出来的一个值，这个值和地址值有关，但是不是实际地址值。
你可以理解为地址值。
*
public final class getclass():返回此 object 的运行时类
class类的方法：
public string getname()：以 string 的形式返回此 class 对象所表示的实体
public class studenttest {
system.out.println(s1.hashcode()); // 11299397
student s2 = new student();
system.out.println(s2.hashcode());// 24446859
system.out.println(s3.hashcode()); // 11299397
system.out.println("-----------");
class c = s.getclass();
string str = c.getname();
system.out.println(str); // cn.itcast_01.student
//链式编程
string str2 = s.getclass().getname();
system.out.println(str2);
protected void finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定。
protected object clone():创建并返回此对象的一个副本。
a:重写该方法
* cloneable:此类实现了 cloneable 接口，以指示 object.clone() 方法可以合法地对该类实例进行按字段复制。
*
这个接口是标记接口，告诉我们实现该接口的类就可以实现对象的复制了。
public static void main(string[] args) throws clonenotsupportedexception {
//创建学生对象
s.setname("林青霞");
s.setage(27);
//克隆学生对象
object obj = s.clone();
student s2 = (student)obj;
system.out.println("---------");
system.out.println(s.getname()+"---"+s.getage());
system.out.println(s2.getname()+"---"+s2.getage());
//以前的做法
student s3 = s;
system.out.println(s3.getname()+"---"+s3.getage());
//其实是有区别的
s3.setname("刘意");
s3.setage(30);
(5)两个注意问题；
a:直接输出一个对象名称，其实默认调用了该对象的tostring()方法。
b:面试题
==和equals()的区别?
a:==
基本类型：比较的是值是否相同
引用类型：比较的是地址值是否相同
只能比较引用类型。默认情况下，比较的是地址值是否相同。
但是，我们可以根据自己的需要重写该方法。
java帮帮交流群