1 OOP特征2:继承性
-
当多个类中存在相同的属性和方法时,将这些内容抽取到单独的类中,其他的类只需要继承这个类就能具有相同的属性和方法。
-
子类(派生类)-父类(基类);可以理解为“子类 is a 父类”
-
类继承的语法是:class Subclass extends SuperClass()
-
子类继承了父类,就继承了父类的方法和属性。在子类中,可以适用父类的属性和方法,也可以拥有自己的属性和方法。
-
另外就是,对于private的父类私有属性和方法,子类不能直接访问。(可以通过get set方法)
-
java中只支持单继承和多层继承
public class Person {
String name;
char sex;
int age;
public Person(String name, char sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
//因为都继承于Object所以再有toString方法就是子类重写了父类方法。
public String toString(){
return "姓名:"+name+", 性别:"+sex+", 年龄:"+age;
}
}
public class Student extends Person {
long number;
int math;
int english;
int computer;
public Student(String name, char sex, int age, long number, int math, int english, int computer) {
super(name, sex, age);
this.number = number;
this.math = math;
this.english = english;
this.computer = computer;
}
public double aver(){
return (math+english+computer)/number;
}
public int max(){
int maxNumber = math;
if (english > maxNumber){
maxNumber = english;
}else if(computer > maxNumber){
maxNumber = computer;
}
return maxNumber;
}
}
2 方法重写
①定义:
在子类中可以根据需要对从父类继承来的方法进行改造,也成为方法的重置、覆盖。在程序执行时,子类覆盖父类的方法。
②要求:
-
子类重写父类方法的时候必须具备和父类一样的方法名和参数列表。
一般!就适用快捷键(Ctrl + O)或者Alt + insert —>插入override method
-
子类重写的返回值类型不能大于父类被重写的方法的返回值类型。
一般就是一样就好了
-
子类重写方法的适用权限不能小于父类被重写的方法的访问权限
一般就一样好了;子类不能重写父类声明为private权限的方法。
-
子类方法抛出的异常不能大于父类被重写的异常
③注意:
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写),或者同时声明为static的(不是重写)。因为static方法是属于类的,子类无法覆盖父类的方法。
④实例:
Person类:父类
public class Person {
public String name;
public int age;
public String getInfo(){
return "Name :"+ name + "\n" + "age : "+age;
}
}
Student类:子类
public class Student extends Person {
public String school;//子类私有的属性
public String getInfo(){//重写了父类的getInfo方法。
return "Name: "+name+"\nage: "+age+"\nschool: "+school;
}
}
测试类:
public class TestOverride {
@Test
public void testStudent(){
Student student = new Student();
student.school = "哈尔滨师范大学";
student.age = 23;
student.name = "纪伟";
System.out.println(student.getInfo());
}
@Test
public void testPerson(){
Person person = new Person();
person.age = 22;
person.name = "孙妍";
String info = person.getInfo();
System.out.println(info);
}
}
⑤重写与重载
-
重载,是指允许存在多个同名方法,但是这些方法的参数不同。不表现为多态性。
重载,在方法调用之前就确定了要调用的方法,称为“早绑定”或“静态绑定”。
-
重写,子类对于父类方法功能的改造或覆盖,方法名和参数列表都相同。表现为多态性。
重写,由于多态,只有方法调用的那一刻,才确定要调用的方法,称为“晚绑定”或“动态绑定”
3 四种访问权限修饰符
4 关键字:super
①概述
可以使用super来调用父类的指定操作
-
super可以用于访问父类定义的属性 ”super.属性“
-
super可以调用父类中定义的成员方法 ”super.方法“
-
super可以在子类构造器中调用父类的构造器
②注意:
-
super的追溯不仅限于直接父类
-
调用父类的构造器!!!
- 子类的所有构造器都默认访问父类中空参数的构造器
- 当父类中没有空参的构造器时,子类必须通过**this(参数列表)或者super(参数列表)**语句指定调用本类或者父类中相应的构造器。同时,只能”二选一”,且必须放在构造器的首行。
-
在实例化子类对象的时候,子类的构造器中首行都默认含有一个super(),默认调用父类的空参构造器,目的是调用父类非私有的属性和方法;
也可以显示的调用super(xxx),调用父类有参构造,前提是父类具有这个有参构造。
在实例化子类对象的时候,在堆内存中有一个子类的空间,这个空间里面有一个父集空间,存放的是父类的非私有的属性和方法。
父类:
public class Person {
private String name;
private int age;
private Date birthDate;
//三个参数的构造器
public Person(String name, int age, Date birthDate) {
this.name = name;
this.age = age;
this.birthDate = birthDate;
}
//两个参数的构造器
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//两个参数的构造器
public Person(String name, Date birthDate) {
this.name = name;
this.birthDate = birthDate;
}
//一个参数的构造器
public Person(String name) {
this.name = name;
}
}
子类:
public class Student extends Person {
private String school;
public Student(String name, int age, String school) {
super(name, age);
this.school = school;
}
public Student(String name, String school){
super(name);
this.school = school;
}
public Student(String school){
super();//编译出错!!!这是因为父类中没有空参的构造器,而此时系统将会调用父类无参的构造器。解决方法:
可以在父类中创建空参的构造器
this.school = school;
}
}
5 子类对象的实例化过程
- 从结果上看:(继承性)
- 子类继承父类后,就获取了父类中声明的方法和属性
- 创建子类的对象,在堆空间,就会加载所有父类中声明的属性!!
- 从过程上看:
- 当我们通过子类的构造器创建子类对象时,我们一定会直接或间接的调用其父类的构造器,进而调用父类的父类的构造器…直到调用了java.lang.Object类中空参的构造器为止。正式因为加载过所有的父类结构,所以才可以看到内存中有父类中的结构,子类对象才可以考虑进行调用。
6 OOP特征3:多态性
①概念
-
理解多态性:可以理解为一个事物的多种形态
-
何为多态性:父类的引用指向子类的对象(或子类的对象赋给父类的引用)
Person p = new man(); Object obj = new Date();
②多态的使用
-
多态的使用:虚拟方法调用
有了对象的多态性以后,我们在编译期,只能调用父类中声明的方法,但在运行期,我们实际执行的是子类重写父类的方法
总结:编译,看左边;运行,看右边
多态是运行时行为!!!
-
多态的使用前提:①类的继承关系;②方法的重写
-
对象的多态性,只适用于方法,不适用于属性(编译和运行都看左边!)
public class PersonTest {
public static void main(String[] args) {
//多态性:父类的引用指向了子类的对象
Person person = new Student("纪伟", 24, "哈尔滨师范大学");
person.say();//学生说话!
Person person1 = new Person();
person1.say();//人说话
Student student = new Student("孙妍", 22, "青岛农业大学");
student.say();//学生说话!
}
}
③instanceof操作符
x instanceof A:检验x是否为类A 的对象,返回值为boolean型。
- 要求x所属的类与类A必须时子类和父类的关系,否则编译错误
- 要求x属于类A的子类B,x instanceof A值也为true
Person p1 = new Student;
System.out.println(p1 instanceof Person);//true
System.out.println(p1 instanceof Student);//true
④对象类型转换
基本数据类型转换
-
自动类型转换:小的数据类型 转换成 大的数据类型:比如说
int a = 10; double b = a;
或者:double c = 10;因为10是int比double小,所以可以自动转换成double类型的10.0
-
强制类型转换:把大的数据类型强制转换成小的数据类型:比如说
int a = (int) 3.1415926;
输出为3,原因是强转 会导致精度降低。
对象类型转换
- 子类到父类的类型转换可以自动进行:
- 父类到子类的类型转换必须通过造型(强制类型转换)实现
- 无继承关系的引用类型间的转换是非法的
- 在造型前可以使用instanceof操作符测试一个对象的类型
⑤代码实例
测试类:
public class GeometricTest {
public static void main(String[] args) {
//因为要调用测试类定义的方法,所以实例化测试类
GeometricTest test = new GeometricTest();
//实例化circle对象,赋初始值。
Circle c1 = new Circle(3.3, "white", 1.0);
test.displayGeometricObject(c1);
Circle c2 = new Circle(3.3, "white", 1.0);
//调用test对象的比较面积方法:
boolean isEquals = test.equalsArea(c1, c2);
System.out.println("c1和c2的面积是否相等:"+isEquals);
//实例化rectangle对象,赋初始值。
MyRectangle rectangle = new MyRectangle("white", 1.0, 2.1, 3.4);
test.displayGeometricObject(rectangle); //实参是一个子类类型的,形参是父类类型的,调用重写的方法实际上就是调用了子类的重写方法。
}
//显示对象的面积,形参是一个几何图形的父类,实参是一个具体图行的子类,都是调用重写的方法,这就用到了对象的多态性。
public void displayGeometricObject(GeometricObject o){
System.out.println("面积为:"+o.findArea());
}
//判断两个面积是否相等
public boolean equalsArea(GeometricObject o1, GeometricObject o2){
return o1.findArea() == o2.findArea();
}
}
子父类:
//父类
public class GeometricObject {
protected String color;//父类的属性
protected double weight;
protected GeometricObject(String color, double weight){//父类一个全参的构造器
this.color = color;
this.weight = weight;
}
//父类的findArea方法
public double findArea(){
return 0.0;
}
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类
public class Circle extends GeometricObject{
private double radius;//子类私有的半径属性
public Circle(double radius, String color, double weight) {//子类的构造器
super(color, weight);//必须显示用super调用父类的构造器
this.radius = radius;
}
@Override//重写父类的findArea方法
public double findArea() {
return Math.PI*radius*radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
}
//子类MyRectangle类
public class MyRectangle extends GeometricObject{
private double width;//私有的属性
private double height;
public MyRectangle(String color, double weight, double width, double height) {//子类构造器
super(color, weight);
this.width = width;
this.height = height;
}
@Override//重写父类的findArea方法
public double findArea() {
return width*height;
}
public double getWidth() {
return width;
}
public void setWidth(double width) {
this.width = width;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
}
7 Object类的使用
①概念
-
Object类是所有Java类的根父类
-
如果在类的声明中未使用extends关键字指明其父类,则默认父类为java.lang.Object类
-
Object类中只声明了一个空参的构造器
②==操作符和equals方法
-
==:
基本类型比较:只有两个变量的值相等,则为true
引用类型比较:看是否指向同一个对象,也就是地址值相同则相等。
用“==”进行比较的时候两边的数据类型必须兼容,(可自动转换的基本数据类型除外)
-
equals():
所有类都继承了Object类,也就获得了equals()方法。
- Object类的equals()方法,源码就是用“==”比较。
子类如String、File、Date及包装类(Wrapper Class)都重写了父类Object的equlas方法,所以他们的比较不一样。
-
区别:
- ==既可以比较基本数据类型(比较值)也可以比较引用数据类型(内存地址)
- equals,是属于java.lang.Object类里面的方法,如果没有重写的话就是==,像string等类的equals都是重写过的。
③如何重写equals()
class User{
String name;
int age;
//重写其equals()方法
public boolean equals(Object obj){
if(obj == this){
return true;
}
if(obj instanceof User){
User u = (User)obj;
return this.age == u.age && this.name.equals(u.name);
}
return false;
}
}
④toString()方法
-
toString()方法再Object类中定义,其返回值是String类型,返回类名和它的引用地址。如下:
practice08.Circle@14ae5a5
practice08.Circle@7f31245a -
可以根据需要在用户自定义类型中重写toString()方法
如String 类重写了oString()方法,返回字符串的值。
s1=“hello”;
System.out.println(s1);//相当于System.out.println(s1.toString());
-
基本类型数据转换成String类型时,调用了对于包装类的toString()方法
int a = 10;
System.out.println(“a=”+a);
public class CircleTest {
public static void main(String[] args) {
Circle circle1 = new Circle(2.3);
Circle circle2 = new Circle("white",3.3, 2.0);
System.out.println("颜色是否相等:"+circle1.getColor().equals(circle2.getColor()));
System.out.println("半径是否相等: "+circle1.equals(circle2));
System.out.println("默认调用:"+circle1);//默认调用了重写的toString方法
System.out.println(circle2.toString());//和上面是一样的都是调用重写的toString方法!
}
}
public class GeometricObject {
protected String color;
protected double weight;
protected GeometricObject(){
color = "white";
weight = 1.0;
}
protected GeometricObject(String color, double weight){
this.color = color;
this.weight = weight;
}
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;
}
}
public class Circle extends GeometricObject{
private double radius;
public Circle() {
super();
radius = 1.0;
}
public Circle(double radius) {
// super();
this.radius = radius;
}
public Circle(String color, double weight, double radius) {
super(color, weight);
this.radius = radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
//计算圆的面积
public double findArea(){
return Math.PI*radius*radius;
}
//比较两个圆的半径是否相等,若相等返回true
@Override
public boolean equals(Object obj) {
if (this==obj){
return true;
}
if (obj instanceof Circle){
Circle c = (Circle)obj;
return this.radius == c.radius;
}
return false;
}
//重写toString方法
@Override
public String toString() {
return "Circle [radius="+radius+"]";
}
}
8 单元测试方法
Java中的JUnit单元测试
- 创建Java类的要求:
- 此类是public的
- 此类提供公共的无参的构造器‘
- 创建单元测试方法:
- 方法权限是public,没有返回值,没有形参
- 单元测试方法上声明注解:@Test
import org.junit.Test;
public class JunitTest{
@Test
public void Test(){
}
}
9 包装类的使用
①装箱-拆箱(基本数据类型<–>)
基本数据类型包装成包装类的实例–装箱
int i = 500;
Integer t = new Integer(i);
Float f = new Float(“4.56”);
获得包装类对象中包装的基本类型变量
-
调用包装类的.xxxValue()方法:
boolean b = bObj.booleanValue();
②类型转换
字符串转换成基本数据类型
-
通过包装类的构造器实现:
int i = new Integer(“12”);
-
通过包装类的parseXxx(String s)静态方法:
Float f = Float.parseFloat(“12.1”);
基本数据类型转换成字符串
-
调用字符串重载的valueOf()方法:
String fstr = String.valueOf(2.34f);
-
更直接的方式:
String intStr = 5 + “”
③用法举例
int i = 500;
Integer t = new Integer(i);
装箱:包装类使得一个基本数据类型的数据变成了类。
有了类的特点,可以调用类中的方法。
String s = t.toString(); // s = “500“,t是类,有toString方法
String s1 = Integer.toString(314); // s1= “314“ 将数字转换成字符串。
String s2=“4.56”;
double ds=Double.parseDouble(s2); //将字符串转换成数字
拆箱:将数字包装类中内容变为基本数据类型。
int j = t.intValue(); // j = 500,intValue取出包装类中的数据
包装类在实际开发中用的最多的在于字符串变为基本数据类型。
String str1 = "30" ;
String str2 = "30.3" ;
int x = Integer.parseInt(str1) ; // 将字符串变为int型
float f = Float.parseFloat(str2) ; // 将字符串变为int型