2017年3月27号 星期一 晴 空气质量：优
内容：this，继承，多态，Object，final，abstract
一、this
老师总结的未能及时手抄下来，所以网上查找相关内容摘抄如下：
（一）百度知道，原文地址：https://zhidao.baidu.com/question/202377968.html
this表示类实例本身。
this的用法
1、表示对当前对象的引用！
public class A{
public A getA(){
return this;//表示获取当前实例本身
}
}
2、表示类的成员变量，而非函数参数，注意在函数参数和成员变量同名是进行区分！
public class A{
private int a = 0;//位置1
public A getA(int a){
this.a = a;//前面this.a表示 位置1 的a，赋值=号右侧的表示参数a
}
}
3、用于在构造方法中引用满足指定参数类型的构造器。
public class A{
public A(int a){
}
public A(){
this(1);//这里调用自身的构造函数public A(int a){
}
}
（二）博客部分引用，原文地址：http://blog.csdn.net/fzfengzhi/article/details/2174406
this主要要三种用法：
１、表示对当前对象的引用！
２、表示用类的成员变量，而非函数参数，注意在函数参数和成员变量同名是进行区分！
３、用于在构造方法中引用满足指定参数类型的构造方法。但是这里必须非常注意：只能引用一个构造方法且必须位于开始！
4、注意：this不能用在static方法中！
二、继承（图示及老师写的demo）
1、老师代码：
1）狗狗的实体类（子类）
package cn.bdqn.bean;
/**
*狗狗的实体类
*/
public class Dog extends Pet {
private String strain; // 品种
// 无参构造方法
public Dog() {
// super(); 默认 调用父类的无参构造
// super("小黑黑2", 50, 100); // 显式的调用父类的带参构造
System.out.println("Dog类的无参构造函数！");
}
// 带参构造函数
public Dog(String name, String strain, int health, int love) {
System.out.println("Dog类的带参构造函数！");
this.strain = strain;
}
/**
* 输出自身特有的方法
* 重写了父类的showInfo（）
*
* 重写的特点：
* 01.有继承关系
* 02.不同类
* 03.方法名一致
* 04.参数列表一致 （个数，顺序，类型）
* 05.子类的访问权限修饰符不能严于父类
* 06.返回值相同或者是其子类
*
* super的使用
* super.属性
* super.方法 前提是 父类的属性和方法是公共权限的！
*
* super(): 调用父类的无参构造
* 01. 如果子类的构造方法没有显式的调用super()
* 系统会默认调用super();---->执行父类的无参构造
* 02.如果子类的构造方法显式的调用父类的带参构造super(参数1，参数2)！
* 这时候就不会执行父类的无参构造了！！
* super(参数1，参数2) :调用父类的带参构造
*/
public void showInfo() {
super.showInfo(); // 调用父类的方法
System.out.println("品种是：" + this.strain);
}
/**
* 重写 返回值相同或者是其子类
*/
@Override
public Dog getPet() {
return new Dog();
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
}
2）企鹅的实体类（子类）
package cn.bdqn.bean;
/**
*企鹅的实体类
*/
public class Penguin extends Pet {
public String sex; // 性别
// 带参构造
public Penguin(String name, int health, int love, String sex) {
System.out.println("Penguin的带参构造");
this.sex = sex;
}
/**
* 重写父类的方法
*/
@Override
public void showInfo() {
super.showInfo();
System.out.println("性别是：" + sex);
}
// 无参构造
public Penguin() {
System.out.println("Penguin的无参构造");
}
}
3）宠物类（父类）
package cn.bdqn.bean;
/*
* 父类：宠物类
*/
public class Pet {
// 成员变量 子类 共有的属性
private String name; // 姓名
private int health;// 健康值
private int love;// 亲密度
// 父类的无参构造
public Pet() {
System.out.println("父类Pet的无参构造");
}
// 带参构造
public Pet(String name, int health, int love) {
System.out.println("父类Pet的带参构造");
this.name = name;
this.health = health;
this.love = love;
}
/**
* 输出宠物的信息 所有宠物 共享的！
*/
public void showInfo() {
System.out.println("姓名:" + this.name);
System.out.println("健康值:" + this.health);
System.out.println("亲密度:" + this.love);
}
/**
* 验证 重写返回值相同或者是其子类
* @return Pet是父类
*/
public Pet getPet() {
return new Pet();
}
// 对应的set和get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
}
4）测试类
package cn.bdqn.test;
//测试类
import cn.bdqn.bean.Dog;
public class PetTest {
/**
* 测试 Dog和 Penguin类 是否继承了 三个属性一个方法？？
*
* 01.如果一个类继承了某个类
* 那么在实例化子类的时候，必须是先实例化它的父类！
* 02.java中所有类的父类是 Object！
*/
public static void main(String[] args) {
// 创建一个Dog
Dog dog = new Dog();
dog.setHealth(100);
dog.setLove(100);
dog.setName("小白白");
dog.setStrain("小狼狗");
// 输出自身的信息
dog.showInfo();
}
}
三、继承、重写和super的使用
1、老师总结笔记：
* 01.如果一个类继承了某个类
* 那么在实例化子类的时候，必须是先实例化它的父类！
* 02.java中所有类的父类是 Object！
* 重写的特点：
* 01.有继承关系
* 02.不同类
* 03.方法名一致
* 04.参数列表一致 （个数，顺序，类型）
* 05.子类的访问权限修饰符不能严于父类
* 06.返回值相同或者是其子类
*
* super的使用
* super.属性
* super.方法 前提是 父类的属性和方法是公共权限的！
*
* super(): 调用父类的无参构造
* 01. 如果子类的构造方法没有显式的调用super()
* 系统会默认调用super();---->执行父类的无参构造
* 02.如果子类的构造方法显式的调用父类的带参构造super(参数1，参数2)！
* 这时候就不会执行父类的无参构造了！！
* super(参数1，参数2) :调用父类的带参构造
四、重写 Object类中的equals方法
1、老师代码：
package cn.bdqn.equals;
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;
}
/**
* 重写 Object类中的equals方法
* Object：是需要我们传递的参数类型！
*/
@Override
public boolean equals(Object obj) {
if (this == obj) { // 内存地址一致 肯定返回true
return true;
}
if (!(obj instanceof Student)) { // 用户传递来的obj是否属于Student类的对象
return false; // 类型都不一致 没有可比性
}
// 向下转型 Object 转换成 Student
Student student = (Student) obj; // student就可以点出来属性和方法
if (student.getAge() == this.age && student.getName().equals(this.name)) {
return true;
} else {
return false;
}
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
public static void main(String[] args) {
Student stu1 = new Student("小黑", 50);
Student stu2 = stu1;
// 默认会输出Object类中的toString（）
System.out.println(stu1);
System.out.println(stu1.hashCode());
System.out.println(stu2.hashCode());
}
/** public static void main(String[] args) {
Student stu1 = new Student("学生11", 50);
Student stu2 = new Student("学生11", 50);
// 上面两个对象的属性完全一致
System.out.println(stu1 == stu2); // 引用数据类型比较的是地址
*/
/**
* public boolean equals(Object obj) {
return (this == obj);
}
*/
/*
* System.out.println(stu1.equals(stu2)); // false ??
* System.out.println("**************************************");
*//**
* 如果对象的属性值 完全一致！ 我们认为这两个对象时同一个对象！
*A instanceof B ：判断A 是否属于B
* System.out.println("stu1 instanceof Object===>"
* + (stu1 instanceof Object));
*/
/*
*
* }
*/
}
五、多态，abstract和final
1、老师文档总结：
1）abstract
吃饭的方法!
* 发现的问题：
* 01.父类中写的这句话！没有意义！因为每个子类中的eat都是不同的！
* 02.eat（）不能删除！ 因为是一个共有的方法！公共的行为！
* 03.不需要有方法体！子类重写了！
* 解决的思路：
* 01.在方法上加入 abstract修饰符
* 02.抽象方法必须在抽象类中！抽象方法不允许有方法体！
* 03.怎么把类变成抽象类！ 在类上加入abstract修饰符！
* 04.子类中必须重写父类的所有抽象方法！除非子类也是抽象类！
* 05.抽象类不能实例化！但是可以书写构造方法！
* 06.抽象类中可以有普通的方法！
2） final
* 如果类不希望被继承！ 在类上加入 final 修饰！ 但是 final不能和abstract连用！
* 如果方法不希望被重写！ 在方法上加入 final 修饰！
* 如果属性不希望被修改！在属性上加入 final 修饰！
2、老师代码：
1)狗狗实体类
package cn.bdqn.bean;
/**
*狗狗的实体类
*/
public class Dog extends Pet {
private String strain; // 品种
// 无参构造方法
public Dog() {
}
// 带参构造函数
public Dog(String name, String strain, int health, int love) {
this.strain = strain;
}
/**
* 重写父类的方法
*/
public void showInfo() {
super.showInfo(); // 调用父类的方法
System.out.println("品种是：" + this.strain);
}
public String getStrain() {
return strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
/**
* 重写了父类的eat()
*/
@Override
public void eat() {
System.out.println("dog在吃骨头");
}
}
2)企鹅的实体类
package cn.bdqn.bean;
/**
*企鹅的实体类
*/
public class Penguin extends Pet {
public String sex; // 性别
// 带参构造
public Penguin(String name, int health, int love, String sex) {
System.out.println("Penguin的带参构造");
this.sex = sex;
}
/**
* 重写父类的方法
*/
@Override
public void showInfo() {
super.showInfo();
System.out.println("性别是：" + sex);
}
// 无参构造
public Penguin() {
}
/**
* 重写父类的eat()
*/
@Override
public void eat() {
System.out.println("企鹅在吃鱼...");
}
}
3)宠物抽象类
package cn.bdqn.bean;
//宠物抽象类
public abstract class Pet {
// 成员变量 子类 共有的属性
private String name; // 姓名
private int health;// 健康值
private int love;// 亲密度
// 父类的无参构造
public Pet() {
}
// 带参构造
public Pet(String name, int health, int love) {
this.name = name;
this.health = health;
this.love = love;
}
/**
* 输出宠物的信息 所有宠物 共享的！
*/
public void showInfo() {
System.out.println("姓名:" + this.name);
System.out.println("健康值:" + this.health);
System.out.println("亲密度:" + this.love);
}
/**
* 吃饭的方法!
* 发现的问题：
* 01.父类中写的这句话！没有意义！因为每个子类中的eat都是不同的！
* 02.eat（）不能删除！ 因为是一个共有的方法！公共的行为！
* 03.不需要有方法体！子类重写了！
*
* 解决的思路：
* 01.在方法上加入 abstract修饰符
* 02.抽象方法必须在抽象类中！抽象方法不允许有方法体！
* 03.怎么把类变成抽象类！ 在类上加入abstract修饰符！
* 04.子类中必须重写父类的所有抽象方法！除非子类也是抽象类！
* 05.抽象类不能实例化！但是可以书写构造方法！
* 06.抽象类中可以有普通的方法！
*
* 如果类不希望被继承！ 在类上加入 final 修饰！ 但是 final不能和abstract连用！
* 如果方法不希望被重写！ 在方法上加入 final 修饰！
* 如果属性不希望被修改！在属性上加入 final 修饰！
*/
public abstract void eat();
// 对应的set和get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getLove() {
return love;
}
public void setLove(int love) {
this.love = love;
}
}
4)小狗狗类（验证final用）
package cn.bdqn.bean;
//小狗狗类（验证final用）
public class SDog extends Dog {
/**
* 验证Dog类中的showInfo()加上了 final
* 子类中就不能重写了！
*/
}
5)宠物测试类（抽象）
package cn.bdqn.test;
//宠物测试类（抽象）
public class PetTest {
public static void main(String[] args) {
/** 抽象的方法
* Dog dog = new Dog();
dog.eat();
Penguin penguin = new Penguin();
penguin.eat();*/
/**
* 01.使用final修饰的引用数据类型变量！不允许被改变！
* 02.变量所指向的对象中的属性是可变的！
* final Dog dog = new Dog();
dog.setStrain("嘿嘿");
dog=new Dog(); 重新赋值不可以*/
}
}
六、访问修饰符的总结（图示）
七、方法重载与方法重写的区别（图示）
八、Object类经常被子类重写的方法（4个）
九、作业（Demo）
1、汽车租赁（轿车、客车）
2、总结笔记（用MindManager）：从开始上课到现在，慢慢来，边总结边消化边查找弱项去加强！
3、多看视频（估计老师下节课会讲完面向对象，所以至少周二晚上要看完异常）
4、做题
十、老师辛苦了！
