本篇文章是根据视频学的，来源如下所示：

教程来源：	java基础到高级_零基础自学Java–尚硅谷–宋红康
教程视频地址：	java基础到高级_零基础自学Java--尚硅谷--宋红康_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1ny4y1Y7CW

1.Eclipse常用快捷键1

2..Eclipse常用快捷键2

3.Eclipse常用快捷键3

4.回顾Bank练习的难点

5.项目二:功能演示

6.项目二:软件结构设计

7.项目二:CMUtility工具类的功能介绍

8.项目二:Customer类的设计

9.项目二:CustomerList类的设计

10.项目二:CustomerView的整体框架的构建

11.项目二:CustomerView的退出功能的实现

12.项目二:CustomerView的客户列表功能的实现

13.项目二:CustomerView添加客户功能的实现

14.项目二:CustomerView修改客户功能的实现

15.项目二:CustomerView删除客户功能的实现

16.项目二:总结

17.继承性的理解

18.继承性的使用

19.继承性的再说明

20.Object类的理解

20.每日一考

21.继承性练习1:基本操作

22.继承性练习2:基本操作

23.EclipseDebug的使用

24.项目二中使用Debug调试

25.解决Debug中step into功能失灵的问题

26.方法重写的理解

27.方法重写的细节

28.方法重写的练习

29.测试4中不同的权限修饰

30.super调用属性和方法---super爱豆的笑容

31.super调用构造器

32.子类对象实例化的全过程

33.继承和super的课后练习

34.多态性的使用------比较难,比较重要的(老师原话)(Polymorphism)

35.多态性使用举例

36.多态性不适用于属性

37.虚拟方法调用的再理解

38.每日一考

39.向下转型的使用

40.instanceof关键字的使用

41.向下转型的几个常见的问题

42.多态练习:调用属性和方法

43.多态性练习:基本操作

44.多态性练习:几何图形

45.多态性练习:重写方法

46.Object类结构的解析

47.==运算符的回顾

48.equals()的使用

49.重写equals()

50.总结equals()与==

51.equals()练习1:代码实现

52.equals()练习2:代码实现

53.toString()的使用

54.Object类综合练习使用

55.单元测试方法的使用

56.包装类的理解

57.基本数据类型转换为包装类

58.包装类转换为基本数据类型

59.新特性:自动装箱与自动拆箱

60.基本数据类型包装类与String的相互转换

61.包装类常见面试问题

62.包装类的课后练习

63.每日一考

1.Eclipse常用快捷键1

2..Eclipse常用快捷键2

3.Eclipse常用快捷键3

补全代码:Alt + /或者改为Windows-----Preference------java-------Editor------Content Assist-------trigger for java之中的内容改为qwertyuiopasdfghjklzxcvbnm.,那么就是任何内容都是提示的了

修改快捷键的方式:Windows - Preference - 搜索(keys) - 修改

package com.atshangguigu.java;import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;/* Eclispse使用的过程中的一些快捷键* 1.快速补全代码声明:Alt + /* 2.快速修复:Ctrl + 1* 3.批量导包:Ctrl + shift + o* 由于显卡的快捷键的存在下面的博主的没有实现* 4.使用单行注释:Ctrl + / 博主改为alt+/* 5.使用多行注释:Ctrl + shift + / 博主这个打算不用* 6.取消多行注释:Ctrl + shift + \ 博主这个也打算不用* 7.复制指定行的代码:Ctrl + (Alt +) down或者Ctrl (+ Alt) + up* 改Eclipse快捷键的方式* 8.删除指定行的代码:ctrl+d* 9.上下移动代码:alt+up/down* 10.在上面插入一个空行:ctrl + shift + enter* 11.如何查看源码:ctrl + 鼠标点击 或者 ctrl + shift + t* 12.退回到前一个编辑的页面:alt + 左* 13.进入到后面的一个编辑的页面:alt + 右* 14.光标选中指定的类,查看继承树的结构:ctrl + t* 15.复制:ctrl + c* 16.撤销:ctrl + z* 17.反撤销:ctrl + y* 18.剪切:ctrl + x* 19.粘贴:ctrl + v* 20.保存:ctrl + s* 21.全选:ctrl + a* 22.格式化代码:ctrl + shitf + f 博主的不能够使用* 23.选中数行整体后移:tab* 24.选中数行整体前移:shift + tab* 25.在当前的类之中，显示类的结构，并且支持搜索指定的方法、属性等：Ctrl+o* 26.批量修改指定的变量名 方法名 类名等:alt+shift+r或者ctrl + f* 27.选中结构的大小写的切换,变成大写:ctrl + shift + x* 28.选中结构的大小写的切换,变成小写:ctrl + shift + y* 29.调出生成getter/setter/构造器等结构:alt + shift + s* 30.显示当前的资源属性信息：alt + enter* 31.快速查找：ctrl + k就是快速的进行查找* * 32.关闭的当前的窗口：ctrl+w* 32.关闭当前的全部窗口：ctrl + shift + w* 33.查看结构使用过的地方：ctrl + shift + g* 34.查找与替换：ctrl + f* 35.最大化当前的View：ctrl + m* 36.直接定位到当前行的首位:home* 37.直接定位到当前行的尾部:end* */
public class EclipseKeys {final double pi = 3.14;//这里表明他是一个常量
public static void main(String[] args) {String s = new String();String str = new String();ArrayList list = new ArrayList();HashMap map = null;int map1 = 12;map1 = 18;Date date = new Date(123456);
}
}
class User
{
private int Id;
private String name
public int getId() {return Id;
}
public void setId(int id) {Id = id;
}
public String getName() {return name;
}
public void setName(String name) {this.name = name;
}
public User(int id, String name) {Id = id;this.name = name;
}；}

4.回顾Bank练习的难点

客户信息管理软件

5.项目二:功能演示

详见视频

6.项目二:软件结构设计

7.项目二:CMUtility工具类的功能介绍

8.项目二:Customer类的设计

9.项目二:CustomerList类的设计

10.项目二:CustomerView的整体框架的构建

11.项目二:CustomerView的退出功能的实现

12.项目二:CustomerView的客户列表功能的实现

13.项目二:CustomerView添加客户功能的实现

14.项目二:CustomerView修改客户功能的实现

15.项目二:CustomerView删除客户功能的实现

16.项目二:总结

17.继承性的理解

学生继承人类(代码如下所示)
Person.java

package com.atshangguigu.java;public class Person {String name;int age;public Person(){}public Person(String name,int age){this.name = name;this.age = age;}public void eat(){System.out.println("还有一个多小时我就可以去吃饭了");}public void sleep(){System.out.println("今天中午睡到了下午两点半");}}

Student.java

package com.atshangguigu.java;
/** 已经定义了一个Person类,这里我们可以直接继承Person类里面的东西*/
public class Student extends Person{//这里使用extends Person那么我们就可以直接继承Person之中的东西//String name;//int age;String major;public Student(){}public Student(String name,int age,String major){this.name = name;this.age = age;this.major = major;}public void study(){System.out.println("小杨在努力学习Java呀!");}}

ExtendTest.java

package com.atshangguigu.java;
/** 面向对象的特征二:继承性* 1.减少代码的冗余,提高了代码的复用性* 2.便于功能的拓展* 3.为了之后的多态性的使用提供了前提
*/
public class ExtendTest {
public static void main(String[] args) {Person p1 = new Person();p1.age = 1;p1.eat();Student s1 = new Student();s1.eat();s1.sleep();s1.name = "Yang";}
}

18.继承性的使用

Person.java

package com.atshangguigu.java;public class Person {String name;private int age;public Person(){}public Person(String name,int age){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;}public void eat(){sleep();System.out.println("还有一个多小时我就可以去吃饭了");}private void sleep(){System.out.println("今天中午睡到了下午两点半");}}

Student.java

package com.atshangguigu.java;
/** 已经定义了一个Person类,这里我们可以直接继承Person类里面的东西*/
public class Student extends Person{//这里使用extends Person那么我们就可以直接继承Person之中的东西//String name;//int age;String major;public Student(){}public Student(String name,int age,String major){this.name = name;setAge(age);this.major = major;}public void study(){System.out.println("小杨在努力学习Java呀!");}public void show(){System.out.println("name:" + name + ",age:" + getAge());}
}

ExtendTest.java

package com.atshangguigu.java;
/** 面向对象的特征二:继承性  * 一.继承性的好处* 1.减少代码的冗余,提高了代码的复用性* 2.便于功能的拓展* 3.为了之后的多态性的使用提供了前提* * 二.继承性的格式:class A extends B{}*   A：子类、派生类、subclass*  B：父类、超类、基类、superclass*  2.1体现：一旦子类A继承了父类B中的声明的结构：属性、方法(私有的继承到了,但是隐藏起来了-隐形基因)*  特别的,父类之中声明为private的属性或者方法,子类继承父类以后,仍然认为获取了父类中的私有的结构.*  只有因为封装性的影响,使得子类不能够直接调用父类的结构而已.封装性与继承性是互补冲突的,各自调用自己的*  2.2子类继承父类以后,还可以声明自己特有的属性和方法:实现功能的拓展*  子类和父类的关系,不同的子集和集合之间的关系.*/
public class ExtendTest {
public static void main(String[] args) {Person p1 = new Person();//p1.age = 1;p1.eat();Student s1 = new Student();s1.eat();//s1.sleep();s1.name = "Yang";s1.setAge(10);System.out.println(s1.getAge());}
}

19.继承性的再说明

* 三.java中关于继承性的一些规定

1.一个类可以被多个子类继承.(一个人可以生多个孩子)
        2.java之中的单继承性:一个类只能有一个父类.(吕布:你再骂?)[C++之中可以有多个父类]
        3.子父类是一个相对的概念.多层继承(祖爷爷-爷爷-爸爸-儿子:四世同堂-----基因的角度)
        4.子类直接继承的父类称为直接父类,间接继承的父类称为:间接父类
        5.子类继承父亲以后,就直接获取了父类以及间接父类之中的所有的已经声明的属性以及方法.

20.Object类的理解和每日一考(缺少)

创建一个类,之后直接调用------未知的继承父类("我爸爸是谁?")
Creature s = new Creature(); s.-----可以知道,.后面自己产生相应的函数.
四.
1.如果我们没有显式声明一个类的父亲的话,则直接继承java.lang.Object类
2.所有的java类(除了java.lang.Object类之外)都是直接或者间接的继承于java.lang.Object类
3.意味着,所有的java类具有java.lang.Object类声明的功能.

21.继承性练习1:基本操作

箭头:子类指向父类

package day12;
/*
(1)定义一个ManKind类，包括
成员变量int sex和int salary；方法void manOrWoman()：根据sex的值显示“man”(sex==1)或者“woman”(sex==0)；
方法void employeed()：根据salary的值显示“no job”(salary==0)或者“ job”(salary!=0)。*/
public class ManKind {//属性private int sex;private int salary;//构造器public ManKind() {}public ManKind(int sex, int salary) {super();this.sex = sex;this.salary = salary;}//方法void manOrWoman(){if(sex == 1){System.out.println("man");}else if(sex == 0){System.out.println("woman");}else{System.out.println("中性");}}void employeed(){String job = ((salary == 0)?"no job":"job");System.out.println(job);}public int getSex() {return sex;}public void setSex(int sex) {this.sex = sex;}public int getSalary() {return salary;}public void setSalary(int salary) {this.salary = salary;}}

package day12;
/*
(2)定义类Kids继承ManKind，并包括
成员变量int yearsOld； 方法printAge()打印yearsOld的值。*///   这里javabean的条件是1.类是公共的 2.无参构造器 3.私有的属性(get与set的方法)//   [后面在反射的过程之中会提及]
public class Kid extends ManKind{//属性private int yearsOld;//构造器public Kid() {}public Kid(int yearsOld) {this.yearsOld = yearsOld;}//方法public void printAge(){System.out.println("I am " + yearsOld + "years old ");}public int getYearsOld() {return yearsOld;}public void setYearsOld(int yearsOld) {this.yearsOld = yearsOld;}}

package day12;
/*
(3)定义类KidsTest，在类的main方法中实例化Kids的对象someKid，用该对象访问其父类的成员变量及方法。*/
public class KidTest {
public static void main(String[] args) {Kid somekid = new Kid(12);somekid.printAge();somekid.setSex(0);somekid.setSalary(18);somekid.manOrWoman();somekid.employeed();
}
}

22.继承性练习2:基本操作

下面是博主按照自己的理解写的,可能与视频有一些出入.

package com.atshangguigu.exer;
/** */
public class Circle {private double radius;//半径public Circle(){radius = 1.0;}public double getRadius() {return radius;}public void setRadius(double radius) {this.radius = radius;}//返回圆的半径public double findArea(){return Math.PI * getRadius() * getRadius();}
}

package com.atshangguigu.exer;public class Cylinder extends Circle{private double length;Cylinder(){length = 1.0;}public double getLength() {return length;}public void setLength(double length) {this.length = length;}double findVolumn(){return getLength()*findArea();}
}

package com.atshangguigu.exer;public class FinalTest {
public static void main(String[] args) {Cylinder test = new Cylinder();System.out.println(test.findVolumn());test.setRadius(58.2);test.setLength(12);System.out.println(test.findVolumn());
}
}

23.EclipseDebug的使用

在实际开发之中会用的比较多
如何调试程序：
1. System.out.println().
2. Eclipse - Debug调试
加入断点的方法:双击(断点可以理解成为一个个小的关卡,在程序之中我们可以设置多个断点)----右键(点击debug as ):显示小臭虫界面

相应的界面如下所示:

Drop to frame:到达首行的位置

24.项目二中使用Debug调试

25.解决Debug中step into功能失灵的问题

没有进入方法内部:原因是Debug Configurations --- JRE(jdk1.8.0)->具体过程见视频

26.方法重写的理解

package com.atshangguigu.exer1;public class Person {String name;int age;public Person(){}public Person(String name,int age){this.name = name;this.age = age;}public void eat(){System.out.println("吃饭");}public void walk(int distance){System.out.println("我今天走了" + distance + "公里");}
}

package com.atshangguigu.exer1;public class Student extends Person {String major;public Student(){}public Student(String major){this.major = major;}public void study(){System.out.println("我爱天津");}public void eat(){System.out.println("学生一顿吃两份米饭,因为学五食堂的米饭太少了");}
}

package com.atshangguigu.exer1;
/** 方法的重写:* 1.重写:子类继承父类以后,可以对父类之中同名同参数的方法,进行覆盖操作* 2.应用:重写以后,当创建子类对象以后,通过子类对象调用父类同名同参数的方法时候,实际调用的是子类重写父类的方法*/
public class StudentTest {
public static void main(String[] args) {Student s = new Student("仪器仪表工程");s.eat();s.walk(18);s.study();
}
}

面试题:区分方法的重载与重写

27.方法重写的细节

Person.java

package com.atshangguigu.exer1;public class Person {String name;int age;public Person(){}public Person(String name,int age){this.name = name;this.age = age;}//对其进行重写public void eat(){System.out.println("吃饭");}public void walk(int distance){System.out.println("我今天走了" + distance + "公里");eat();show();}private void show()//私有方法{System.out.println("我不是一个好人呀");}public Object info(){return null;}public double info1(){return 10.0;}
}

Student.java

package com.atshangguigu.exer1;public class Student extends Person {String major;public Student(){}public Student(String major){this.major = major;}public void study(){System.out.println("我爱天津");}public void eat(){System.out.println("学生一顿吃两份米饭,因为学五食堂的米饭太少了");}//这里是不能够重写的,因为这里前面可以见到没有一个绿三角,说明没有重写public void show()//私有方法{System.out.println("我是一个好学生");}public String info()//这里的含义是我们将父类之中的Object改为了String{return null;}/*int与 double是并列的关系public int info1(){return 10.0;}*/
}

StudentTest.java

package com.atshangguigu.exer1;
/** 方法的重写:* 1.重写:子类继承父类以后,可以对父类之中同名同参数的方法,进行覆盖操作* 2.应用:重写以后,当创建子类对象以后,通过子类对象调用父类同名同参数的方法时候,*   实际调用的是子类重写父类的方法* 3.重写的规定:*    方法的声明:权限修饰符 返回值类型 方法名(形参列表)*             {*             方法体*             }*             约定俗成:子类中叫重写的方法,父类中叫被重写的方法*      1.子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同*      2.子类重写的方法的权限修饰符不小于父类之中的权限修饰符*        特殊情况:子类不能够重写父类之中的private的方法*      3.返回值类型:*        父类被重写的方法的返回值是void,则子类重写的方法的返回值类型也只能是void.*        父类被重写的方法的返回值类型是A类型,则子类重写方法的返回值类型可以是A类或者A类的子类*        父类被重写的方法的返回值类型是基本数据类型,那么子类重方法的返回值类型也必须是一样的*      4.子类重写的方法抛出的异常类型不大于父类被重写抛出的异常类型*             权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型*             {*             方法体*             }*        父类是:Object----异常是Exception *        子类是:String----异常是Runtime Exception*        [这部分内容具体在异常处理的部分再讲]*      5.具体的开发方式我们通常采用直接粘贴的,那么是绝对错不了的.------人类的智慧就都是为了偷懒*      6.重写的快捷键,使用Alt+/进行* *-*-*-*-***-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*      子类与父类之中的同名同参数的方法要么都声明为非static的(考虑重写),要么声明为static的(这样的就不叫重写了).     */
public class StudentTest {
public static void main(String[] args) {Student s = new Student("仪器仪表工程");s.eat();s.walk(18);//通过这句话证明子类不能够重写父类之中的priate的方法s.study();}
}

28.方法重写的练习

上面的第二题是非常简单的,这里的代码就不重复粘贴了.代码量比较大,没有什么意义.

29.测试4中不同的权限修饰

如上所示,在Browse之中可以直接改掉新建的class的继承的父类.
java2下面的

package com.atshangguigu.java2;
/** 体会四种不同的权限修饰*/
public class Order {private int orderPrivate;int orderDefault;protected int orderProtected;public int orderPublic;private void methodPrivate(){orderPrivate = 1;orderDefault = 2;orderProtected = 3;orderPublic = 4;}void methodDefault(){orderPrivate = 1;orderDefault = 2;orderProtected = 3;orderPublic = 4;}protected void methodProtected(){orderPrivate = 1;orderDefault = 2;orderProtected = 3;orderPublic = 4;}public void methodPublic(){orderPrivate = 1;orderDefault = 2;orderProtected = 3;orderPublic = 4;}
}

java3下面的SubOrder.java

package com.atshangguigu.java3;
import com.atshangguigu.java2.Order;
public class SubOrder extends Order {public void method(){orderProtected = 1;orderPublic = 2;methodProtected();methodPublic();/*在不同的包的子类之中,不能够调用Order类中的声明为private和缺省权限的属性以及方法orderDefault = 3;orderPrivate = 4;methodDefault();methodPrivate();*/}}

java3下面的OrderTest.java

package com.atshangguigu.java3;import com.atshangguigu.java2.Order;//ctrl + shift + o是进行导包的一个过程public class OrderTest {
public static void main(String[] args) {Order order = new Order();//不同包下的普通类要是想要调用Order之中的属性与方法,只能调用的是public类,其余的什么private 缺省 protected是调用不了的//order.orderPrivate = 1;
//  order.orderDefault = 2;
//  order.orderProtected = 3;order.orderPublic = 4;// order.methodDefault();
//  order.methodProtected();order.methodPublic();}
}

30.super调用属性和方法---super爱豆的笑容

属性是没有覆盖的,方法是有的
弹幕:super是this的爹
Person.java

package com.atshangguigu.java4;public class Person {String name;int age;int id = 1;//身份证号public Person(){}public Person(String name){this.name = name;}public Person(String name,int age){this(name);this.age = age;}public void eat(){System.out.println("还有一个小时就要去吃饭了");}public void walk(){System.out.println("生下来就会跑");}
}

student.java

package com.atshangguigu.java4;public class Student extends Person{String major;int id = 20212023;//学号public Student(){}public Student(String major){this.major = major;}@Overridepublic void eat(){super.eat();System.out.println("今天去学四食堂吃米饭,还是去学五食堂吃麻辣烫?");}public void study(){System.out.println("今天晚上有一节激光测量技术课");}public void show(){System.out.println("name = " + super.name + ",age = " + this.age);System.out.println("学号是" + id);System.out.println("身份证号是" + super.id);}}

SuperTest.java

package com.atshangguigu.java4;
/** super关键字的使用* 1.super可以理解为父类的* 2.super可以用来调用属性 方法 构造器* 3.super的使用*   3.1我们可以在子类的方法或构造器之中,通过使用"super.属性"或者"super.方法"的方式,显式的调用父类之中的声明的属性或者方法*     但是通常情况下,我们习惯省略"super"*  3.2特殊情况:当子类和父类中定义了同名的属性时,我们想要在子类中调用父类中的声明属性,必须显式的使用"super.属性"的方式,表明*     调用的是父类之中的声明*  3.3特殊的情况:当子类重写父类中的方法以后,我们想要在子类之中调用父类之中的被重写的方法的时候,必须显式的使用"super.方法"的方式,表明*     调用的是父类之中的声明*/
public class SuperTest {
public static void main(String[] args) {Student stu = new Student();stu.show();stu.study();stu.eat();
}
}

31.super调用构造器

Person.java

package com.atshangguigu.java4;public class Person {String name;int age;int id = 1;//身份证号public Person(){System.out.println("我是猪八");}public Person(String name){this.name = name;}public Person(String name,int age){this(name);this.age = age;}public void eat(){System.out.println("还有一个小时就要去吃饭了");}public void walk(){System.out.println("生下来就会跑");}
}

Student.java

package com.atshangguigu.java4;public class Student extends Person{String major;int id = 20212023;//学号public Student(){}public Student(String major){this.major = major;}public Student(String name,int age,String major){super(name,age);this.major = major;}@Overridepublic void eat(){super.eat();System.out.println("今天去学四食堂吃米饭,还是去学五食堂吃麻辣烫?");}public void study(){System.out.println("今天晚上有一节激光测量技术课");}public void show(){System.out.println("name = " + this.name + ",age = " + this.age);System.out.println("学号是" + id);System.out.println("身份证号是" + super.id);}}

SuperTest.java

package com.atshangguigu.java4;
/** super关键字的使用* 1.super可以理解为父类的* 2.super可以用来调用属性 方法 构造器* 3.super的使用*   3.1我们可以在子类的方法或构造器之中,通过使用"super.属性"或者"super.方法"的方式,显式的调用父类之中的声明的属性或者方法*     但是通常情况下,我们习惯省略"super"*  3.2特殊情况:当子类和父类中定义了同名的属性时,我们想要在子类中调用父类中的声明属性,必须显式的使用"super.属性"的方式,表明*     调用的是父类之中的声明*  3.3特殊的情况:当子类重写父类中的方法以后,我们想要在子类之中调用父类之中的被重写的方法的时候,必须显式的使用"super.方法"的方式,表明*     调用的是父类之中的声明* 4.super调用构造器*  4.1我们可以在子类的构造器之中显式的使用"super(形参列表)"的方式,调用父类中声明的指定的构造器*  4.2"super(形参列表)"的使用,必须声明在子类构造器的首行*  4.3我们在类的构造器之中,针对"this(形参列表)"或者"super(形参列表)"只能二选一,不能同时出现*  4.4在构造器的首行,没有显式的声明"this(形参列表)"或"super(形参列表)",则默认调用的是父类中的空参构造器super();*  4.5在类的多个构造器之中,至少有一个类的构造器中使用了"super(形参列表)",调用父类的构造器*/
public class SuperTest {
public static void main(String[] args) {Student stu = new Student();stu.show();stu.study();stu.eat();Student s1 = new Student("Yang",23,"仪器工程 哼!");s1.show();System.out.println("*-*-*-*--*-*-*-*-*-*--*-*-*-*-*-");Student s2 = new Student();
}
}

32.子类对象实例化的全过程

* 子类对象实例化的全过程
* 1.从结果上看:(继承性)
* 子类继承父类以后,就获取了父类中声明的属性和方法
* 创建子类对象,在堆空间之中,就会加载所有父类中的声明的属性
* 2.从过程上看:
* 当我们通过子类的构造器创建对象的时候,我们一定会直接或者间接的调用父类构造器,
* 进而调用父类的父类的构造器,因为加载过所有父类的结构,所以才可以看到内存之中有
* 父类的结构,子类对象才可以进行调用.
* 明确:虽然创建子类对象时,调用了父类的构造器,但是只是创建过一个对象,也就是那个new 出来的对象.

33.继承和super的课后练习

Account.java

package com.atshangguigu.java6;
/*1、写一个名为 Account 的类模拟账户。该类的属性和方法如下图所示。该类包括的属性：
账号 id，余额 balance，年利率 annualInterestRate；包含的方法：访问器方法（getter 和
setter 方法），返回月利率的方法 getMonthlyInterest()，取款方法 withdraw()，存款方法
deposit()。*/
public class Account {private int id;//账号private double balance;//存款private double annualInterestRate;//年利率//构造器public Account(int id, double balance, double annualInterestRate) {super();this.id = id;this.balance = balance;this.annualInterestRate = annualInterestRate;}public int getId() {return id;}public void setId(int id) {this.id = id;}public double getBalance() {return balance;}public void setBalance(double balance) {this.balance = balance;}public double getAnnualInterestRate() {return annualInterestRate;}public void setAnnualInterestRate(double annualInterestRate) {this.annualInterestRate = annualInterestRate;}//月利率public double getMonthlyInterest(){return annualInterestRate / 12;}//取钱public void withdraw (double amount){if (balance >= amount){balance -= amount;return ;}else{System.out.println("余额不足,没钱了");return ;}}//存钱public void deposit (double amount){balance += amount;}
}

AccountTest.java

package com.atshangguigu.java6;
/*写一个用户程序测试 Account 类。1.在用户程序中，创建一个账号为 1122、余额为 20000、年利率 4.5%的 Account 对象。2.使用 withdraw 方法提款 30000 元，并打印余额。3.再使用 withdraw 方法提款 2500 元，使用 deposit 方法存款 3000 元，然后打印余额和月利率。* */
public class AccountTest {
public static void main(String[] args) {Account test = new Account(1122,20000,0.045);test.withdraw(30000);System.out.println("您的账户余额为" + test.getBalance());test.withdraw(2500);test.deposit(3000);System.out.println("您的账户余额为" + test.getBalance() + "  当前账户的月利率为" + 100*test.getMonthlyInterest() + "%");
}
}

CheckAccount.java

package com.atshangguigu.java6;
/*2、创建 Account 类的一个子类 CheckAccount 代表可透支的账户，该账户中定义一个属性
overdraft 代表可透支限额。在 CheckAccount 类中重写 withdraw 方法，其算法如下：如果（取款金额<账户余额），可直接取款如果（取款金额>账户余额），计算需要透支的额度判断可透支额 overdraft 是否足够支付本次透支需要，如果可以将账户余额修改为 0，冲减可透支金额如果不可以提示用户超过可透支额的限额*/
public class CheckAccount extends Account{private double overdraft;//可透支限额public CheckAccount(int id, double balance, double annualInterestRate,double overdraft){super(id,balance,annualInterestRate);this.overdraft = overdraft;}public double getOverdraft() {return overdraft;}public void setOverdraft(double overdraft) {this.overdraft = overdraft;}@Overridepublic void withdraw(double amount) {if(getBalance() >= amount ){    //方式一//setBalance(getBalance() - amount);//方式二super.withdraw(amount);}else if(overdraft >= (amount - getBalance()))//透支额度加上余额是足够的{overdraft -= (amount - getBalance());setBalance(0);//或者是super.withdraw(getBalance());}else{System.out.println("超过可以透支的限额");}}}

CheckAccountTest.java

package com.atshangguigu.java6;
/*要求：写一个用户程序测试 CheckAccount 类。在用户程序中，创建一个账号为 1122、余
额为 20000、年利率 4.5%，可透支限额为 5000 元的 CheckAccount 对象。
使用 withdraw 方法提款 5000 元，并打印账户余额和可透支额。
再使用 withdraw 方法提款 18000 元，并打印账户余额和可透支额。
再使用 withdraw 方法提款 3000 元，并打印账户余额和可透支额。*/
public class CheckAccountTest {
public static void main(String[] args) {CheckAccount acc = new CheckAccount(1122,20000,0.045,5000);acc.withdraw(5000);System.out.println("您的账户余额为:" + acc.getBalance());System.out.println("您的可透支额度为:" + acc.getOverdraft());acc.withdraw(18000);System.out.println("您的账户余额为:" + acc.getBalance());System.out.println("您的可透支额度为:" + acc.getOverdraft());acc.withdraw(3000);System.out.println("您的账户余额为:" + acc.getBalance());System.out.println("您的可透支额度为:" + acc.getOverdraft());
}
}

34.多态性的使用------比较难,比较重要的(老师原话)(Polymorphism)

Person.java

package com.atshangguigu.java7;public class Person {String name;int age;public void eat(){System.out.println("生而为猪,我很能吃");}public void walk(){System.out.println("见过猪跑没");}}

Man.java

package com.atshangguigu.java7;public class Man extends Person{boolean isMoking;public void earnMoney(){System.out.println("挣钱,娶老婆");}public void eat(){System.out.println("多吃饭");}public void walk(){System.out.println("删库,跑路");}public void isSmoking(){system.out.println("男生可以抽烟");}
}

Woman.java

package com.atshangguigu.java7;public class Woman extends Person{boolean isBeauty;public void goShopping(){System.out.println("女生喜欢购物");}public void eat(){System.out.println("不吃饭");}public void walk(){System.out.println("走路");}
}

PersonTest.java

package com.atshangguigu.java7;
/** 面向对象的特征三:多态性* * 1.理解多态性:可以理解为一个事物的多种形态* 2.何为多态性:父类的引用指向子类的对象(子类的对象指向父类的引用)* 3.多态的使用:虚拟方法的使用*        有了对象的多态性以后,我们在编译的时候,只能调用父类中声明的方法,但是在运行的时候,我们实际* 调用的是子类重写父类的方法.* 总结:编译看左边,运行看右边------找共性* 4.多态性的使用前提:* (1)要有类的继承关系* (2)要有方法的重写* * */
public class PersonTest {
public static void main(String[] args) {Person p1 = new Person();p1.eat();Man man = new Man();man.eat();man.age = 23;man.earnMoney();//*-*-*--*-*-*-*-*-*--*--*-*-*--*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*//这就是多态性//对象的多态性:父类的引用指向子类的对象Person p2 = new Man();//多态的使用:当调用子父类同名同参数的方法时,实际执行的是子类重写父类的方法-----虚拟方法调用(此处不用深究)p2.eat();//这里调用的是子类的方法p2.walk();//形象的比喻:假设叫个秘书,秘书找个人,然后一块出去吃饭(男人和女人的饭量就不是一样的)//p2.earnMoney();//编译的时候看的是左边的,运行的时候看的是右边的(弹幕:编译向左,运行向右)}
}

35.多态性使用举例

package com.atshangguigu.java7;import java.sql.Connection;public class AnminalTest {public static void main(String[] args) {AnminalTest test = new AnminalTest();test.func(new Ribbit());test.func(new Cat());}public void func(Anminal anminal){anminal.eat();anminal.shout();}//如果没有多态性的存在,那么我们就要重写以下的代码//就要造出来很多的重载的方法public void func(Ribbit anminal){anminal.eat();anminal.shout();}public void func(Cat anminal){anminal.eat();anminal.shout();}}
class Anminal
{public void eat(){System.out.println("动物:恰饭");}public void shout(){System.out.println("动物:叫");}
}
class Ribbit extends Anminal
{public void eat(){System.out.println("小白兔:恰萝卜");}public void shout(){System.out.println("小白兔:汪汪汪(不知道咋叫)");}
}
class Cat extends Anminal
{public void eat(){System.out.println("小黑猫：吃小鱼");}public void shout(){System.out.println("小黑猫：喵喵喵");}
}//举例二:
class Order
{public void method(Object obj){}
}
//举例三:
class Driver
{public void doData(Connection conn)//Connection是一个父类结构,实际传的是子类的对象{//conn = new MySQLConnection();//操作规范的步骤
//      conn.method1();
//      conn.method2();}
}

36.多态性不适用于属性

在Person之中定义一个id = 1001;
在Student之中定义一个id = 1002;
通过使用Person p = new Student();
调用打印p.id的结果是1001

对象的多态性只是适用于方法,不适用于属性.

37.虚拟方法调用的再理解

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法(就是感觉父类是比较虚的,因为叫虚拟方法)，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的,只有在运行的时候才知道。
面试题:多态是一个编译时行为还是运行时行为?(详细解释如下所示)

package com.atshangguigu.java3;import java.util.Random;//面试题：多态是编译时行为还是运行时行为？
//证明如下：
class Animal  {protected void eat() {System.out.println("animal eat food");}
}class Cat  extends Animal  {protected void eat() {System.out.println("cat eat fish");}
}class Dog  extends Animal  {public void eat() {System.out.println("Dog eat bone");}}class Sheep  extends Animal  {public void eat() {System.out.println("Sheep eat grass");}}public class InterviewTest {public static Animal  getInstance(int key) {switch (key) {case 0:return new Cat ();case 1:return new Dog ();default:return new Sheep ();}}public static void main(String[] args) {int key = new Random().nextInt(3);System.out.println(key);Animal  animal = getInstance(key);animal.eat();}}

对上述代码进行解释,就是随机产生一个随机数,分别对应着不同的动物,而每个动物有不同的方式.------运行过程我们称之为动态绑定

这个方法的重载与写是需要注意的,面试的时候可能会问到

38.每日一考

先会写代码,理解的事慢慢来------老师原话

什么是多态性？什么是虚拟方法调用？

对象的多态性：父类的引用指向子类的对象。

Person p = new Man();

p.eat();

调用方法时，编译时看左边，运行时看右边。

一个类可以有几个直接父类？（只有一个）
一个父类可有多少个子类？（多个）
子类能获取直接父类的父类中的结构吗？（可以）A is B---true?决定继承
子类能否获取父类中private权限的属性或方法？(可以的)
方法的重写(override/overwrite)的具体规则有哪些？

方法名、形参列表相同

权限修饰符

返回值

抛出的异常

super调用构造器，有哪些具体的注意点 (放在首行,且二者必须二选一或者进行默认进行构造器)

this(形参列表)：本类重载的其它的构造器

super(形参列表):调用父类中指定的构造器

n n – 1 1

39.向下转型的使用

在前面的PersonTest.java之中进行添加

//p2.earnMoney();//编译的时候看的是左边的,运行的时候看的是右边的(弹幕:编译向左,运行向右)//不能够调用子类特有的方法 属性,编译的时候,p2是Person的类型//p2.earnMoney();p2.name = "Yang";//p2.isSmoking = true;//内存之中是否已经声明了man里面的特有的属性,由于我们已经重新声明的是一个Person类型,因此是调用不了的//有了对象的多态性以后,内存中实际加载了子类之中特有的属性与方法,但是由于变量声明为父类对象类型//编译的时候只能调用父类的属性与方法,子类的属性与方法是不能够用的//如何调用子类之中特有的属性与方法?---使用强制类型转换//向下转型---强制类型转换     向上转型---自动类型转换(多态)Man m1 = (Man) p2;m1.earnMoney();m1.isSmoking();//使用强制转换的时候,可能会出现ClassCastException的异常
//比如下面的代码
//Woman w1 = (Woman)p2;
//w1.goShopping();
//instanceof:的使用

40.instanceof关键字的使用

下面是PersonTest.java的代码

package com.atshangguigu.java;
/** 面向对象的特征三:多态性* * 1.理解多态性:可以理解为一个事物的多种形态* 2.何为多态性:父类的引用指向子类的对象(子类的对象指向父类的引用)* 3.多态的使用:虚拟方法的使用*        有了对象的多态性以后,我们在编译的时候,只能调用父类中声明的方法,但是在运行的时候,我们实际* 调用的是子类重写父类的方法.* 总结:编译看左边,运行看右边------找共性* 4.多态性的使用前提:* (1)要有类的继承关系* (2)要有方法的重写* 5.对象的多态性只适用于方法,不适用于属性(编译和运行都是要看左边的)* * */
public class PersonTest {
public static void main(String[] args) {Person p1 = new Person();p1.eat();Man man = new Man();man.eat();man.age = 23;man.earnMoney();//*-*-*--*-*-*-*-*-*--*--*-*-*--*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*//这就是多态性//对象的多态性:父类的引用指向子类的对象Person p2 = new Man();//多态的使用:当调用子父类同名同参数的方法时,实际执行的是子类重写父类的方法-----虚拟方法调用(此处不用深究)p2.eat();//这里调用的是子类的方法p2.walk();//形象的比喻:假设叫个秘书,秘书找个人,然后一块出去吃饭(男人和女人的饭量就不是一样的)//p2.earnMoney();//编译的时候看的是左边的,运行的时候看的是右边的(弹幕:编译向左,运行向右)//不能够调用子类特有的方法 属性,编译的时候,p2是Person的类型//p2.earnMoney();p2.name = "Yang";//p2.isSmoking = true;//内存之中是否已经声明了man里面的特有的属性,由于我们已经重新声明的是一个Person类型,因此是调用不了的//有了对象的多态性以后,内存中实际加载了子类之中特有的属性与方法,但是由于变量声明为父类对象类型//编译的时候只能调用父类的属性与方法,子类的属性与方法是不能够用的//如何调用子类之中特有的属性与方法?---使用强制类型转换//向下转型---强制类型转换     向上转型---自动类型转换(多态)Man m1 = (Man) p2;m1.earnMoney();m1.isSmoking();//使用强制转换的时候,可能会出现ClassCastException的异常//比如下面的代码//Woman w1 = (Woman)p2;//w1.goShopping();/*instanceof关键字的使用* * a instanceof A:判断对象a是不是类A的实例,如果是那么返回true,否则返回false* * 使用情形:为了避免在向下转型时候出现ClassCastException的异常,我们在向下转型之前,先要进行* instanceof的判断,一旦返回true,就进行向下转型.如果返回false,那么就不进行向下转型.* * 如果a instanceof A返回true,且a instanceof B也是true,那么B是A的父类.*/if(p2 instanceof Woman){Woman w1 = (Woman)p2;w1.goShopping();System.out.println("p2是一个Woman");}else{System.out.println("p2不是一个Woman");}if(p2 instanceof Man){System.out.println("p2是Man");}else{System.out.println("p2不是Man");}if(p2 instanceof Person){System.out.println("p2是Person");}else{System.out.println("p2不是Person");}if(p2 instanceof Object){System.out.println(" Yes ");}else{System.out.println("No");}
}
}

41.向下转型的几个常见的问题

package com.atshangguigu.java;
/** 面向对象的特征三:多态性* * 1.理解多态性:可以理解为一个事物的多种形态* 2.何为多态性:父类的引用指向子类的对象(子类的对象指向父类的引用)* 3.多态的使用:虚拟方法的使用*        有了对象的多态性以后,我们在编译的时候,只能调用父类中声明的方法,但是在运行的时候,我们实际* 调用的是子类重写父类的方法.* 总结:编译看左边,运行看右边------找共性* 4.多态性的使用前提:* (1)要有类的继承关系* (2)要有方法的重写* 5.对象的多态性只适用于方法,不适用于属性(编译和运行都是要看左边的)* * */
public class PersonTest {
public static void main(String[] args) {Person p1 = new Person();p1.eat();Man man = new Man();man.eat();man.age = 23;man.earnMoney();//*-*-*--*-*-*-*-*-*--*--*-*-*--*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*//这就是多态性//对象的多态性:父类的引用指向子类的对象Person p2 = new Man();//多态的使用:当调用子父类同名同参数的方法时,实际执行的是子类重写父类的方法-----虚拟方法调用(此处不用深究)p2.eat();//这里调用的是子类的方法p2.walk();//形象的比喻:假设叫个秘书,秘书找个人,然后一块出去吃饭(男人和女人的饭量就不是一样的)//p2.earnMoney();//编译的时候看的是左边的,运行的时候看的是右边的(弹幕:编译向左,运行向右)//不能够调用子类特有的方法 属性,编译的时候,p2是Person的类型//p2.earnMoney();p2.name = "Yang";//p2.isSmoking = true;//内存之中是否已经声明了man里面的特有的属性,由于我们已经重新声明的是一个Person类型,因此是调用不了的//有了对象的多态性以后,内存中实际加载了子类之中特有的属性与方法,但是由于变量声明为父类对象类型//编译的时候只能调用父类的属性与方法,子类的属性与方法是不能够用的//如何调用子类之中特有的属性与方法?---使用强制类型转换//向下转型---强制类型转换     向上转型---自动类型转换(多态)Man m1 = (Man) p2;m1.earnMoney();m1.isSmoking();//使用强制转换的时候,可能会出现ClassCastException的异常//比如下面的代码//Woman w1 = (Woman)p2;//w1.goShopping();/*instanceof关键字的使用* * a instanceof A:判断对象a是不是类A的实例,如果是那么返回true,否则返回false* * 使用情形:为了避免在向下转型时候出现ClassCastException的异常,我们在向下转型之前,先要进行* instanceof的判断,一旦返回true,就进行向下转型.如果返回false,那么就不进行向下转型.* * 如果a instanceof A返回true,且a instanceof B也是true,那么B是A的父类.*/if(p2 instanceof Woman){Woman w1 = (Woman)p2;w1.goShopping();System.out.println("p2是一个Woman");}else{System.out.println("p2不是一个Woman");}if(p2 instanceof Man){System.out.println("p2是Man");}else{System.out.println("p2不是Man");}if(p2 instanceof Person){System.out.println("p2是Person");}else{System.out.println("p2不是Person");}if(p2 instanceof Object){System.out.println(" Yes ");}else{System.out.println("No");}//练习://问题一:编译的时候通过,运行的时候不通过//举例一
//  Person p3 = new Woman();
//  Man m2 = (Man)p3;//举例二
//  Person p4 = new Person();//想想也不合适
//  Man m4 = (Man) p4;
//  m4.earnMoney();////问题2:编译时候通过,运行的时候也是通过的Object obj = new Woman();Person p = (Person)obj;//问题三:编译不通过
//  Man m5 = new Woman();
//  String str = new Data();}
}

42.多态练习:调用属性和方法

package com.atshangguigu.Exer;public class FieldMethodTest {public static void main(String[] args) {Sub s = new Sub();System.out.println(s.count);//20:这里调用的是Sub之中的方法:就近原则的存在s.display();//20,这里的display()重写了,但是还是执行的是子类之中的代码Base b = s;//将s的地址值赋给bSystem.out.println(b == s);//后面会==进行详细的介绍,这里比较的是二者的地址值是否相同System.out.println(b.count);//这里是属性,是不是具有多态性的b.display();//20这里的是方法,是具有多态性的------虚拟方法的调用}
}class Base {//属性int count = 10;public void display() {System.out.println(this.count);}
}class Sub extends Base {//属性:不体现多态性int count = 20;public void display() {System.out.println(this.count);}
}

这里需要注意:同名的属性和同名的方法
总结:

1.若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的

同名方法，系统将不可能把父类里的方法转移到子类中.

2.对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的

实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量.(属性)
编译看左边,运行看右边

43.多态性练习:基本操作

package com.atshangguigu.Exer;
/*建立InstanceTest 类，在类中定义方法method(Person e);
在method中:
(1)根据e的类型调用相应类的getInfo()方法。
(2)根据e的类型执行：
如果e为Person类的对象，输出： “a person”;
如果e为Student类的对象，输出：
“a student”
“a person ”
如果e为Graduate类的对象，输出：
“a graduated student”
“a student”
“a person”*/
public class InstanceTest {
public static void main(String[] args) {InstanceTest test = new InstanceTest();test.method(new Student());//虚拟的方法调用}public void method(Person e){//虚拟方法的调用String info = e.getInfo();System.out.println(info);//方式一if(e instanceof Graduate){System.out.println("a graduated student");System.out.println("a student");System.out.println("a person");}else if(e instanceof Student){System.out.println("a student");System.out.println("a person");}else if(e instanceof Person){System.out.println("a person");}//方式二if(e instanceof Graduate){System.out.println("a graduated student");}if(e instanceof Student){System.out.println("a student");}if(e instanceof Person){System.out.println("a person");}}
}class Person {protected String name = "person";protected int age = 50;public String getInfo() {return "Name: " + name + "\n" + "age: " + age;}
}class Student extends Person {protected String school = "pku";public String getInfo() {return "Name: " + name + "\nage: " + age + "\nschool: " + school;}
}class Graduate extends Student {public String major = "IT";public String getInfo() {return "Name: " + name + "\nage: " + age + "\nschool: " + school + "\nmajor:" + major;}
}

44.多态性练习:几何图形

练习如下所示:

注意:这里的#代表着protect
GeometricObject.java

package com.atshangguigu.Exer1;public class GeometricObject {//几何图形//1.属性protected String color;protected double weight;//2.get与set的使用public String getColor() {return color;}public void setColor(String color) {this.color = color;}public double getWeight() {return weight;}public void setWeight(double weight) {this.weight = weight;}//3.构造器public GeometricObject(String color, double weight) {super();this.color = color;this.weight = weight;}//进行方法的设定public double findArea()//这里的面积写不出来,只能用微积分{return 0.0;}}

Circle.java

package com.atshangguigu.Exer1;public class Circle extends GeometricObject{//注意刚开始是报错的,因为前面的父类之中的构造器是空参数的,所以这里我们是需要引入的.//1.属性private double radius;//2.构造器public Circle(double radius,String color, double weight) {super(color, weight);this.radius = radius;}//3.set与get的方法public double getRadius() {return radius;}public void setRadius(double radius) {this.radius = radius;}//4.方法public double findArea(){return Math.PI*(this.radius)*(this.radius);}}

MyRectangle.java

package com.atshangguigu.Exer1;public class MyRectangle extends GeometricObject{//1.属性private double height;private double weigh;//2.构造器public MyRectangle(double height,double weigh,String color, double weight) {super(color, weight);this.height = height;this.weight = weigh;}//3.set与get的构建public double getHeight() {return height;}public void setHeight(double height) {this.height = height;}public double getWeigh() {return weigh;}public void setWeigh(double weigh) {this.weight = weigh;}//4.进行求取面积public double findArea(){return this.weight*this.height;}}

GeometricTest.java

package com.atshangguigu.Exer1;
/*
定义一个测试类GeometricTest，编写equalsArea方法测试两个对象的面积是否相等
（注意方法的参数类型，利用动态绑定技术），
编写displayGeometricObject方法显示对象的面积（注意方法的参数类型，利用动态绑定技术）。*/
public class GeometricTest {public static void main(String[] args) {//这个是测试两个圆形GeometricTest test = new GeometricTest();Circle c1 = new Circle(4.0, "黑色", 12.4);test.displayGeometricObject(c1);Circle c2 = new Circle(4.0, "白色", 12.4);test.displayGeometricObject(c2);boolean is = test.equalsArea(c1,c2);System.out.println("c1 和 c2的面积是否相等" + is);}//测试两个面积是否相等public boolean equalsArea(GeometricObject o1,GeometricObject o2){return o1.findArea() == o2.findArea();}//显示对象的面积public void displayGeometricObject(GeometricObject o){System.out.println("面积是:" + o.findArea());}
}

45.多态性练习:重写方法

答案是:运行时行为

package com.atshangguigu.Exer;//考查多态的笔试题目：
public class InterviewTest1 {public static void main(String[] args) {Base1 base = new Sub1();//多态了一下base.add(1, 2, 3);//这里是调用是Sub1之中的.//为什么?因为可以看到代码是画出黄线的,因此是重写,并且从运行结果上看,也是重写.Sub1 s = (Sub1)base;s.add(1,2,3);//优先调用确定个的}
}class Base1 {public void add(int a, int... arr) {System.out.println("base1");}
}class Sub1 extends Base1 {public void add(int a, int[] arr) {System.out.println("sub_1");}public void add(int a, int b, int c) {System.out.println("sub_2");}}

46.Object类结构的解析

//这个视频我没看呀,后面再看

47.==运算符的回顾

48.equals()的使用

49.重写equals()

手动实现重写-----自动生成和之前的set与get是一样的

 //对equals()进行重写//重写的原则:比较两个对象的实体内容是否相同的(没有什么思路,那么看看String是如何写的)@Overridepublic boolean equals(Object obj) {System.out.println("到底执行了吗?");if(this == obj){return true;}if(obj instanceof Customer){Customer cus = (Customer)obj;//比较两个对象的属性是否是一样的/*if(this.age == cus.age && (this.name.equals(cus.name)))//这里应当注意:前面的一个是==,后面的一个是equals(),为啥是equals,//因为后面的cus.name是引用数据类型,因此必须要使用equals(){return true;}else{return false;}*///另外的一种方法是return this.age == cus.age && this.name.equals(cus.name);}return false;}

50.总结equals()与==

不能写null.equals(x);

"=="符号必须表示两边的类型相同或者一致.

51.equals()练习1:代码实现

package com.atshangguigu.Exer2;
/** 1.编写Order类，有int型的orderId，String型的orderName，相应的
getter()和setter()方法，两个参数的构造器，重写父类的equals()方法：
public boolean equals(Object obj)，并判断测试类中创建的两个对象
是否相等。*/
public class OrderTest {public static void main(String[] args) {Order order1 = new Order(1001,"AA");Order order2 = new Order(1000,"BB");System.out.println(order1.equals(order2));Order order3 = new Order(1000,"BB");System.out.println(order2.equals(order3));//true用==,注意,一般String是不能够直接用new的String s1 = "CC";String s2 = "CC";System.out.println(s1 == s2);//true}
}
class Order
{   //属性private int orderId;private String orderName;//set与getpublic int getOrderId() {return orderId;}public void setOrderId(int orderId) {this.orderId = orderId;}public String getOrderName() {return orderName;}public void setOrderName(String orderName) {this.orderName = orderName;}//构造器public Order(int orderId, String orderName) {super();this.orderId = orderId;this.orderName = orderName;}@Overridepublic boolean equals(Object obj) {if(this == obj){return true;}if(obj instanceof Order){ //向下转型Order order = (Order)obj;//return this.orderId == order.orderId && this.orderName.equals(order.orderName);return this.orderId == order.orderId && this.orderName==order.orderName;}return false;}
}

52.equals()练习2:代码实现

package com.atshangguigu.Exer2;public class MyDateTest {public static void main(String[] args) {MyDate m1 = new MyDate(14, 3, 1976);MyDate m2 = new MyDate(14, 3, 1976);if (m1 == m2) {System.out.println("m1==m2");} else {System.out.println("m1!=m2"); // m1 != m2}if (m1.equals(m2)) {System.out.println("m1 is equal to m2");// m1 is equal to m2} else {System.out.println("m1 is not equal to m2");} }
}
class MyDate
{   //属性private int day;private int month;private int year;//get和setpublic int getDay() {return day;}public void setDay(int day) {this.day = day;}public int getMonth() {return month;}public void setMonth(int month) {this.month = month;}public int getYear() {return year;}public void setYear(int year) {this.year = year;}//构造器public MyDate(int day, int month, int year) {super();this.day = day;this.month = month;this.year = year;}//重写public boolean equals(Object obj){if(this == obj){return true;}if(obj instanceof Object ){MyDate mydate = (MyDate)obj;return this.day == mydate.day && this.month == mydate.month && this.year == mydate.year;}return false;}
/*@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;MyDate other = (MyDate) obj;if (day != other.day)return false;if (month != other.month)return false;if (year != other.year)return false;return true;}*/
}

53.toString()的使用

在Customer.java之中进行重写

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

toString.java之中进行继续写代码

package com.atshangguigu.java1;import java.util.Date;/** Object类之中的toString()的使用:* 1.当我们输出一个对象的引用的时候,实际上就是调用当前对象的toString()* 2.Object类中toString()是如何定义的:*   public String toString() *   {return getClass().getName() + "@" + Integer.toHexString(hashCode());//类名+@+内存地址(虚拟的)}3.像String Date File 包装类等都重写了Object之中的toString之中的方法.使得在调用对象的toString()时候,返回"实体内容"信息4.自定义类也可以重写toString()方法的时候,当调用此方法的时候,返回对象的"实体内容"*/
public class toString {
public static void main(String[] args) {Customer cust = new Customer("Tom",12);System.out.println(cust.toString());//输出一个地址值com.atshangguigu.java1.Customer@15db9742System.out.println(cust);String str = new String("MM");System.out.println(str);//MM 这里的String是重写过的,因此是可以输出MM的Date date = new Date(123456789L);System.out.println(date);//Fri Jan 02 18:17:36 CST 1970
}}

54.Object类综合练习使用

GeomtricObject.java

package com.atshangguigu.Exer3;public class GeometricObject {//1.属性protected String color;protected double weight;//2.这里是一个构造器public GeometricObject() {super();this.color = "white";this.weight = 1.0;}public GeometricObject(String color, double weight) {super();this.color = color;this.weight = weight;}//3.get与set的设定public String getColor() {return color;}public void setColor(String color) {this.color = color;}public double getWeight() {return weight;}public void setWeight(double weight) {this.weight = weight;}}

Circle.java

package com.atshangguigu.Exer3;public class Circle extends GeometricObject
{   //1.属性private double radius;//2.构造器public Circle() {super();//  this.color = "white";//this.weight = 1.0;this.radius =1.0;}public Circle(double radius) {super();this.color = "white";this.weight = 1.0;this.radius = radius;}public Circle(String color, double weight, double radius) {super(color, weight);this.radius = radius;}//3.set与getpublic double getRadius() {return radius;}public void setRadius(double radius) {this.radius = radius;}//4.方法public double findArea()//计算圆的面积{return Math.PI*radius*radius;}//5.重写@Overridepublic boolean equals(Object obj) {if(this == obj){return true;}if(obj instanceof Object){Circle circle = (Circle)(obj);return this.radius == radius;}return false;}@Overridepublic String toString() {return "Circle [radius=" + radius + "]";}}

CircleTest.java

package com.atshangguigu.Exer3;public class CircleTest {
public static void main(String[] args) {Circle c1 = new Circle("black",12 , 119);Circle c2 = new Circle("black",12 , 119);boolean isColor = c1.color.equals(c2.color);//这里是protected的,因此这里是可以这样写的,跟视频不一样System.out.println("颜色是否相同" + isColor);boolean isRadius = c1.equals(c2);System.out.println("半径是否相同" + isRadius);System.out.println(c1.toString());System.out.println(c2.toString());}
}

55.单元测试方法的使用

想要测试哪个地方的代码就单独测试哪个地方的代码

package com.atshangguigu.java2;import org.junit.Test;/** Java中的JUnit单元测试* * 步骤:* 1.选中当前工程 - 右键选择:build path - add libraries - JUnit 4 - 下一步(当然博主的和视频里面的不一样,直接百度就能找到,只是方法不一样而已)* 2.创建Java类,进行单元测试.*   此时的Java类的要求是:1.此类是public的 2.提供公共的无参构造器* 3.此类单元测试的测试方法.*   此单元测试方法:方法的权限是public,没有返回值,没有形参* 4.此单元测试方法上需要进行注解:@Test,并在单元测试类之中导入:import org.junit.Test;* 5.声明好代码以后,就可以在方法体内部测试相关的代码.* 6.写完相应的代码之后,双击选中单元测试方法名,右键:run as - JUnit Test* * 说明:* 1.如果执行结果没有任何异常,那么执行结果是一个绿条;有异常的时候是一个红色的条条---红灯停,绿灯行* 2.*/
public class JUnitTest {int num = 10;@Testpublic void testEquals(){String s1 = "MM";String s2 = "GG";System.out.println(s1.equals(s2));System.out.println(num);show();}public void show(){num = 20;System.out.println("show()........");}@Testpublic void testToString(){String s2 = "MM";System.out.println(s2);}
}

在开发的过程之中,直接@Test,然后点一下它就行

56.包装类的理解

基本数据类型真的很单薄.
基本数据类型和Object没有什么关系,基本数据类型相当于一个残疾人,把它给治好了,Interger之中需要一个int,体现了面向对象的思想,面向对象的功能.---这里就可以解释多态的过程之中哪个基本数据类型不能够被多态.(圣斗士---穿上射手座的圣衣就变的很牛逼啦)

57.基本数据类型转换为包装类

基本数据类型包装类和String类之间的转换

package com.atshangguigu.java2;import org.junit.Test;/** 包装类的使用:* 1.java提供了八种数据类型对应的包装类,使得数据类型的变量具有了类的特征* 2.掌握的:基本数据类型 包装类 String之间的转换*/
public class WrapperTest {//基本数据类型如何转换为包装类 :调用包装类的构造器@Testpublic void test1(){int num1 = 10;Integer in1 = new Integer(num1);System.out.println(in1.toString());Integer in2 = new Integer("123");//这里应当注意""之中应当是一个纯粹的数System.out.println(in2);/*Integer in2 = new Integer("123qwert");//这里应当注意""之中应当是一个纯粹的数System.out.println(in2);*/Float f1 = new Float(12.3f);Float f2 = new Float("12.3");System.out.println(f1);System.out.println(f2);Boolean b1 = new Boolean(true);Boolean b2 = new Boolean("true");Boolean b3 = new Boolean("true1234");System.out.println(b2);System.out.println(b3);Order order = new Order();System.out.println(order.isMale);//falseSystem.out.println(order.isFemale);//null 此刻他是一个类了,所以是一个null}
}
class Order
{boolean isMale;Boolean isFemale;
}

58.包装类转换为基本数据类型

 //2.包装类转换为基本数据类型:调用包装类的xxxValue()@Testpublic void test2(){Integer in1 = new Integer(12);int i1 = in1.intValue();System.out.println(i1 + 1);Float f1 = new Float(12.3);float f2 = f1.floatValue();System.out.println(f2 + 1);}

59.新特性:自动装箱与自动拆箱

/** JDK5.0新特性:自动装箱与自动拆箱*/@Testpublic void test3(){
//      int num1 = 10;
//      //基本数据类型---包装类的对象
//      method(num1);//自动装箱:int num2 = 10;Integer in1 = num2;//这里用不着我们再去new//自动装箱boolean b1 = true;Boolean b2 = b1;//自动拆箱:包装类转换为基本数据类型System.out.println(in1.toString());int num3 = in1;}public void method(Object obj){System.out.println(obj);}

这个里面隐含着一个知识点:自动装箱与自动拆箱,公司里面用的都是jdk5.0版本以后的

60.基本数据类型包装类与String的相互转换

 //3.2String类型如何转换为基本数据类型或者包装类:调用包装类的parseXxx()@Testpublic void test5(){String str1 = "456";//这里是不能够写成456Yang,确保数字是可以转换的//错误的情况//int num1 = (int)str1;//Integer in1 = (Integer)str1;int num2 = Integer.parseInt(str1);System.out.println(num2 + 23);String str2 = "false";//只要不是true,都是falseboolean b1 = Boolean.parseBoolean(str2);System.out.println(b1);}//3.1基本数据类型是如何转化为String类型:调用String重载的Valueof(Xxx xxx)@Testpublic void test4(){//方式一:连接运算int num1 = 10;String str1 = num1 + "";//基本数据类型 + ""(字符串)//方式二:调用String的valueOf()的方式float f1 = 12.3f;String str2 = String.valueOf(f1);//"12.3"System.out.println(str2);Double d1 = new Double(12.4);String str3 = String.valueOf(d1);//"12.4"System.out.println(str3);}

61.包装类常见面试问题

package com.atshangguigu.java2;import org.junit.Test;/** 关于包装类使用的面试题目* */
public class Interview {@Test//先要导包:ctrl + shift + opublic void test1() {Object o1 = true ? new Integer(1) : new Double(2.0);//上面的式子,有一个类型的提升,因此是Integer(1)变成了Double()类型的System.out.println(o1);//1.0}@Testpublic void test2() {Object o2;if (true)o2 = new Integer(1);elseo2 = new Double(2.0);//上面没有进行结果的统一System.out.println(o2);//1}@Testpublic void method1() {Integer i = new Integer(1);Integer j = new Integer(1);System.out.println(i == j);//false ==的是地址Integer m = 1;Integer n = 1;System.out.println(m == n);//trueInteger x = 128;Integer y = 128;System.out.println(x == y);//false}//上面的这个题是有难度的--隐含知识点//造好的数组,存了很多的数-128 - 127,这里的数组造好的原因是方便使用,但是当超过了127,就会new一个128//上面也就是new了两个128}

62.包装类的课后练习

差一点,明天写

63.每日一考

七.面向对象编程(中)相关推荐

c语言面向对象编程中的类_C ++中的面向对象编程
c语言面向对象编程中的类 Object oriented programming, OOP for short, aims to implement real world entities like ...
【小白学习C++ 教程】十二、C++面向对象编程中的构造函数和析构函数
@Author:Runsen 面向对象编程旨在:在编程中实现继承.隐藏.多态等现实世界的实体.OOP 的主要目的是将数据和对它们进行操作的函数绑定在一起. 我们可以说C++中的类,代表一组共享一些共同 ...
C＃中面向对象编程中的函数式编程
目录介绍面向对象编程中仿真的函数式编程技术粒度不匹配面向对象的函数式编程构造相互关系函数式编程/面向对象程序设计 C#中的函数式编程集成函数级别的代码抽象操作组合函数部分应用和局部套用 ...
在JavaScript面向对象编程中使用继承(5)
明天就要回老家去过年了,关于这个"在JavaScript面向对象编程中使用继承"的话题居然还没有说完.如果不完成,留下来一拖就拖到明年去了.所以还是抽空把它写完,今年的事情今年做, ...
C# 实例解释面向对象编程中的单一职责原则
在面向对象编程中,SOLID 是五个设计原则的首字母缩写,旨在使软件设计更易于理解.灵活和可维护.这些原则是由美国软件工程师和讲师罗伯特·C·马丁(Robert Cecil Martin)提出的许多原 ...
Objective-C向面向对象编程中添加了一个新概念：类别(categor)。
类别 Objective-C向面向对象编程中添加了一个新概念:类别(categor).类别被设计用于解决这样的问题:基类被认为是很脆弱的,即便是看似无害的改动也不能引入,否则可能会破坏更复杂的派生类. ...
C语言面向对象编程的类是指,c语言面向对象编程中的类_C ++中的面向对象编程...
c语言面向对象编程中的类 Object Oriented programming is a programming style that is associated with the concept ...
python面向对象编程中方法和属性_Python面向对象编程中关于类和方法的学习笔记...
Python面向对象编程中关于类和方法的学习笔记类与类方法是面向对象的编程语言中必不可少的特性,本文总结了Python面向对象编程中关于类和方法的学习笔记,需要的朋友可以参考下类和实例 pytho ...
python面向对象编程中_Python面向对象编程中关于类和方法
类和实例 python是一个面向对象的语言,而面向对象最重要的概念就是类和实例, 记得刚学习的时候不太理解这些概念,直到老师说了一句"物以类聚". 没错就是类, 归类物以类聚类 ...

七.面向对象编程(中)

1.Eclipse常用快捷键1

2..Eclipse常用快捷键2

3.Eclipse常用快捷键3

4.回顾Bank练习的难点

5.项目二:功能演示

6.项目二:软件结构设计

7.项目二:CMUtility工具类的功能介绍

8.项目二:Customer类的设计

9.项目二:CustomerList类的设计

10.项目二:CustomerView的整体框架的构建

11.项目二:CustomerView的退出功能的实现

12.项目二:CustomerView的客户列表功能的实现

13.项目二:CustomerView添加客户功能的实现

14.项目二:CustomerView修改客户功能的实现

15.项目二:CustomerView删除客户功能的实现

16.项目二:总结

17.继承性的理解

18.继承性的使用

19.继承性的再说明

20.Object类的理解和每日一考(缺少)

21.继承性练习1:基本操作

22.继承性练习2:基本操作

23.EclipseDebug的使用

24.项目二中使用Debug调试

25.解决Debug中step into功能失灵的问题

26.方法重写的理解

27.方法重写的细节

28.方法重写的练习

29.测试4中不同的权限修饰

30.super调用属性和方法---super爱豆的笑容

31.super调用构造器

32.子类对象实例化的全过程

33.继承和super的课后练习

34.多态性的使用------比较难,比较重要的(老师原话)(Polymorphism)

35.多态性使用举例

36.多态性不适用于属性

37.虚拟方法调用的再理解

38.每日一考

39.向下转型的使用

40.instanceof关键字的使用

41.向下转型的几个常见的问题

42.多态练习:调用属性和方法

43.多态性练习:基本操作

44.多态性练习:几何图形

45.多态性练习:重写方法

46.Object类结构的解析

47.==运算符的回顾

48.equals()的使用

49.重写equals()

50.总结equals()与==

51.equals()练习1:代码实现

52.equals()练习2:代码实现

53.toString()的使用

54.Object类综合练习使用

55.单元测试方法的使用

56.包装类的理解

57.基本数据类型转换为包装类

58.包装类转换为基本数据类型

59.新特性:自动装箱与自动拆箱

60.基本数据类型包装类与String的相互转换

61.包装类常见面试问题

62.包装类的课后练习

63.每日一考

七.面向对象编程(中)相关推荐

最新文章

热门文章