day11_animal,_eclipse_test,_lianxi,_Obejct

day11_animal

package com.liuyi_01;

/**
 * 这是跳高接口
 * 
 * @author 风清扬
 * @version V1.0
 */
public interface Jump {
/**
* 这是跳高功能
*/
public abstract void jump();

}


package com.liuyi_02;
/**
 * 这是动物抽象类
 * 
 * @author 风清扬
 * @version V1.0
 */
public abstract class Animal {
/**
* 这是吃饭的功能
*/
public abstract void eat();


/**
* 这是睡觉的功能
*/
public abstract void sleep();
}


package com.liuyi_02;
/**
 * 这是具体的猫类
 * 
 * @author 风清扬
 * @version V1.0
 */

public class Cat extends Animal {


@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void sleep() {
System.out.println("猫趴着睡觉");
}

}


package com.liuyi_02;
import com.liuyi_01.Jump;
/**
 * 这是具体的狗类
 * 
 * @author 风清扬
 * @version V1.0
 */
public class Dog extends Animal implements Jump {

@Override
public void jump() {
System.out.println("会跳高的狗");
}


@Override
public void eat() {
System.out.println("狗吃肉");
}


@Override
public void sleep() {
System.out.println("狗站着睡觉");
}

}


day11_eclipse_test

itcast_01

package cn.itcast_01;
public class Demo {

/**
* @param args
*/
public static void main(String[] args) {


}

}


package cn.itcast_01;
public class HelloWorld {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub   
System.out.println("HelloWorld");

System.out.println("aaaa");

int a;
}

}


itcast_02

package cn.itcast_02;


public class Student {
private String name;
private int age;


public int num = 10;
public final int num22 = 20;
public static int num3 = 30;
public static final int num4 = 40;


public Student() {
}


public void setName(String name) {
this.name = name;
}


public String getName() {
return name;
}


public void setAge(int age) {
this.age = age;
}


public int getAge() {
return age;
}

}


itcast_03

package cn.itcast_03;


import cn.itcast_01.HelloWorld;


/*
 * alt+/ 内容辅助键
 * 
 * A:main方法
 * main+alt+/ 回车即可
 * B:输出语句
 * syso+alt+/
 * C:提示作用
 * 帮助你补齐一些你你不住的东西,还可以帮你起名字等。
 */
public class Demo {
// public static void main(String[] args) {
// System.out.println("HelloWorld");
// }


public static void main(String[] args) {
System.out.println();


String string = new String();


HelloWorld helloWorld = new HelloWorld();


}

}


package cn.itcast_03;


import java.util.ArrayList;
import java.util.Date;
import java.util.Scanner;


/*
 * 常用快捷键
 * 1:格式化  ctrl+shift+f
 * 2:导入包  ctrl+shift+o
 * 如果该类仅仅在一个包中有,就自己显示了
 * 如果该类在多个包中有,会弹出一个框框供你选择
 * 3:注释  
 * 单行:注释 ctrl+/,取消注释再来一次。
 * 多行:ctrl+shift+/,ctrl+shift+\
 * 4:代码上下移动 
 * 选中代码alt+上/下箭头
 * 5:查看源码
 * 选中类名(F3或者Ctrl+鼠标点击)
 */
public class HelloWorld {
public static void main(String[] args) {
int a = 10;
System.out.println(a);


Scanner sc = new Scanner(System.in);
Date d = new Date();

// StringBuffer
// ArrayList

Math.random();
}

}


package cn.itcast_04;


/*
 * 提高开发效率:
 * A:帮助我们自动提供构造方法
a:无参构造方法 
在代码区域右键--source--Generate Constructors from Superclass
b:带参构造方法 
在代码区域右键--source--Generate Constructors using fields.. -- finish

   B:成对的getXxx()和setXxx()
    在代码区域右键--source--Generate Getters and Setters...
 */
public class Student {
// 成员变量
private String name;
private int age;

//构造方法
public Student() {
super();
}


public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}


//成员方法
public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}

}

package cn.itcast_04;


public class Teacher {
// 成员变量
private String name;
private int age;


public Teacher(String name, int age) {
super();
this.name = name;
this.age = age;
}


public Teacher() {
super();
// TODO Auto-generated constructor stub
}


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}

}


itcast_05

package cn.itcast_05;


public class Cat extends Animal {


@Override
public void eat() {
System.out.println("猫吃鱼");
}


}


package cn.itcast_05;


/*
 * 是注解。
 * 这个注解的意思是说,我这个方法是重写父类的。
 * 如果和父类名出现了偏差就会报错。
 */
public class Dog extends Animal {


@Override
public void eat() {


}


public void sleep() {


}


}


package cn.itcast_05;


public interface Jump {
public abstract void jump();

}


package cn.itcast_05;


public class Pig extends Animal implements Jump {


@Override
public void jump() {
}


@Override
public void eat() {
}


}


day11_lianxi

itcast_01

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() {
super();
}


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}


public void show() {
System.out.println("姓名:" + name + ",年龄:" + age);
}

}


package cn.itcast_01;


/*
 * 测试类
 */
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();
}

}


itcast_02

package cn.itcast_02;


import com.liuyi_02.Animal;
import com.liuyi_02.Cat;
import com.liuyi_02.Dog;


public class AnimalDemo {
public static void main(String[] args) {
// 抽象类不能实例化
// Animal a = new Animal();


Animal a = new Cat();
a.eat();
a.sleep();


System.out.println("----------");


a = new Dog();
a.eat();
a.sleep();


System.out.println("----------");


// 想使用跳高功能
Dog d = (Dog) a;
d.eat();
d.sleep();
d.jump();
}

}


itcast_03

package cn.itcast_03;


/*
 * 通过debug查看程序执行流程
 * 请大家也做一遍。
 */
public class ArgsDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a:" + a + ",b:" + b);
change(a, b);
System.out.println("a:" + a + ",b:" + b);


int[] arr = { 1, 2, 3, 4, 5 };
change(arr);
System.out.println(arr[1]);
}


public static void change(int a, int b) {
System.out.println("a:" + a + ",b:" + b);
a = b;
b = a + b;
System.out.println("a:" + a + ",b:" + b);
}


public static void change(int[] arr) {
for (int x = 0; x < arr.length; x++) {
if (arr[x] % 2 == 0) {
arr[x] *= 2;
}
}
}

}


package cn.itcast_03;


public class ForDemo {
public static void main(String[] args) {
// 定义求和变量
int sum = 0;


for (int x = 1; x < 6; x++) {
sum += x;
}


System.out.println("sum:" + sum);
}

}


day11_Obejct

itcast_01

package cn.itcast_01;


public class Student extends Object {


}


package cn.itcast_01;


/*
 * Object:类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
 * 每个类都直接或者间接的继承自Object类。
 * 
 * Object类的方法:
 * public int hashCode():返回该对象的哈希码值。
 * 注意:哈希值是根据哈希算法计算出来的一个值,这个值和地址值有关,但是不是实际地址值。
 *            你可以理解为地址值。
 * 
 * public final Class getClass():返回此 Object 的运行时类
 * Class类的方法:
 * public String getName():以 String 的形式返回此 Class 对象所表示的实体
 */
public class StudentTest {
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1.hashCode()); // 11299397
Student s2 = new Student();
System.out.println(s2.hashCode());// 24446859
Student s3 = s1;
System.out.println(s3.hashCode()); // 11299397
System.out.println("-----------");


Student s = new Student();
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);
}

}


itcast_02

package cn.itcast_02;


public class Student {
private String name;
private int age;


public Student() {
super();
}


public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}


@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}


// @Override
// public String toString() {
// // return super.toString();
// // return "hello";
// return "姓名:" + name + ",年龄:" + age;
// }


}


package cn.itcast_02;


/*
 * public String toString():返回该对象的字符串表示。
 * 
 * Integer类下的一个静态方法:
 * public static String toHexString(int i):把一个整数转成一个十六进制表示的字符串
 * 
 * 这个信息的组成我们讲解完毕了,但是这个信息是没有任何意义的。所以,建议所有子类都重写该方法。
 * 怎么重写呢?
 * 把该类的所有成员变量值组成返回即可。
 * 重写的最终版方案就是自动生成toString()方法。
 * 
 * 注意:
 * 直接输出一个对象的名称,其实就是调用该对象的toString()方法。
 */
public class StudentDemo {
public static void main(String[] args) {
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
System.out.println("--------------------");
// toString()方法的值等价于它
// getClass().getName() + '@' + Integer.toHexString(hashCode())
// this.getClass().getName()+'@'+Integer.toHexString(this.hashCode())


// cn.itcast_02.Student@42552c
// cn.itcast_02.Student@42552c


System.out.println(s.getClass().getName() + '@'
+ Integer.toHexString(s.hashCode()));


System.out.println(s.toString());


// 直接输出对象的名称
System.out.println(s);
}

}


itcast_03

package cn.itcast_03;


public class Student {
private String name;
private int age;


public Student() {
super();
}


public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}


@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}

// @Override
// public boolean equals(Object obj) {
// // 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) {
// return true;
// }else {
// return false;
// }
// }

// @Override
// public boolean equals(Object obj) {
// //为了提高效率
// if(this == obj){
// return true;
// }
//
// //为了提供程序的健壮性
// //我先判断一下,obj是不是学生的一个对象,如果是,再做向下转型,如果不是,直接返回false。
// //这个时候,我们要判断的是对象是否是某个类的对象?
// //记住一个格式:对象名 instanceof 类名
// //表示:判断该对象名是否是该类名一个对象
// if(!(obj instanceof Student)){
// return false;
// }
// //如果是就继续
//
// Student s = (Student)obj;
// //System.out.println("同一个对象,还需要向下转型并比较吗?");
// return this.name.equals(s.name) && this.age == s.age;
// }


}


package cn.itcast_03;


/*
 * public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。 
 * 这个方法,默认情况下比较的是地址值。比较地址值一般来说意义不大,所以我们要重写该方法。
 * 怎么重写呢?
 * 一般都是用来比较对象的成员变量值是否相同。
 * 重写的代码优化:提高效率,提高程序的健壮性。
 * 最终版:
 * 其实还是自动生成。
 * 
 * 看源码:
 * public boolean equals(Object obj) {
 * //this - s1
 * //obj - s2
 *        return (this == obj);
 *    }
 * 
 * ==:
 * 基本类型:比较的就是值是否相同
 * 引用类型:比较的就是地址值是否相同
 * equals:
 * 引用类型:默认情况下,比较的是地址值。
 * 不过,我们可以根据情况自己重写该方法。一般重写都是自动生成,比较对象的成员变量值是否相同
 */
public class StudentDemo {
public static void main(String[] args) {
Student s1 = new Student("林青霞", 27);
Student s2 = 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 {}


itcast_04

package cn.itcast_04;


public class Student implements Cloneable {
private String name;
private int age;


public Student() {
super();
}


public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}

@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}

}


package cn.itcast_04;


/*
 * protected void finalize():当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。用于垃圾回收,但是什么时候回收不确定。
 * protected Object clone():创建并返回此对象的一个副本。
 * A:重写该方法
 *
 *  Cloneable:此类实现了 Cloneable 接口,以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。 
 *  这个接口是标记接口,告诉我们实现该接口的类就可以实现对象的复制了。
 */
public class StudentDemo {
public static void main(String[] args) throws CloneNotSupportedException {
//创建学生对象
Student s = new Student();
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());
System.out.println("---------");

//其实是有区别的
s3.setName("刘意");
s3.setAge(30);
System.out.println(s.getName()+"---"+s.getAge());
System.out.println(s2.getName()+"---"+s2.getAge());
System.out.println(s3.getName()+"---"+s3.getAge());

}

}


课堂练习:

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

7:删除项目和导入项目
删除项目
选中项目 – 右键 – 删除
从项目区域中删除
从硬盘上删除

导入项目
在项目区域右键找到import
找到General,展开,并找到
Existing Projects into Workspace
点击next,然后选择你要导入的项目
注意:这里选择的是项目名称

8:要注意的几个小问题
如何查看项目所在路径
选中 -- 右键 -- Properties -- Resource -- Location
导入项目要注意的问题
项目区域中不可能出现同名的项目(新建或者导入)
自己随意建立的文件夹是不能作为项目导入的
修改项目问题
不要随意修改项目名称
如果真要修改,不要忘记了配置文件.project中的
把这里改为你改后的名称


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,并点击,然后看到所有的断点,最后点击那个双叉。

Day10作业

1:形式参数和返回值问题
形式参数
基本类型
引用类型
返回值类型
基本类型
引用类型


2:包的定义及注意事项
package

第一条有效语句
唯一


3:导包及注意事项
import

java.lang不需要导入
java.xxx.yyy.类名; 导入到类的级别

java.xxx.yyy.*; 这个也可以,但是不建议


4:四种权限修饰符及其特点
本类中 同一个包下 不同包下的子类 不同包下的无关类
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y


5:常见的修饰符及组合
类:public
成员变量:private
构造方法:public
成员方法:public


6:内部类的概述及访问特点
把类定义在另一个类的内部,叫内部类。

访问特点:
内部类可以直接访问外部类的成员,包括私有
外部类访问内部类的成员需要创建对象


7:内部类的分类
按照位置不同

成员内部类
局部内部类


8:匿名内部类的格式和应用及面试题
new 类名或者接口名() {
重写方法;
}


9:把面向对象部分的总结看一遍。准备后面使用。

  有问题记录下来问我

 

Day11作业

1:面向对象考试并讲解题目


2:熟练使用Eclipse开发工具

你可能感兴趣的:(Java)