04-面向对象编程(二)

1. 面向对象的特征二:继承性

(1)为什么要有继承性:

(2)通过"class A extends B"类实现类的继承。 子类:A 父类(或基类 SuperClass):B

(3)子类继承父类以后,父类中声明的属性、方法,子类就可以获取到。 明确:当父类中有私有的属性或方法时,子类同样可以获取得到,只是由于封装性的设计,使得子类不可以直接调用罢了。 子类除了通过继承,获取父类的结构之外,还可以定义自己的特有的成分。 extends:子类是对父类功能的“扩展”,明确子类不是父类的子集。

(4)java中类的继承性只支持单继承:一个类只能继承一个父类。反之,一个父类可以有多个子类。

(5)子父类是相对的概念。

方法的重写 1.方法的重写(override orverwrite) vs 重载(overload)

【面试题】方法的重载与重写的区别?

重载:“两同一不同”:同一个类,同一个方法名,不同的参数列表。 注:方法的重载与方法的返回值无关! 构造器是可以重载的

重写:(前提:在继承的基础之上,子类在获取了父类的结构以后,可以对父类中同名的方法进行“重构”) 方法的返回值,方法名,形参列表形同;权限修饰符不小于父类的同名方法;子类方法的异常类型不大于父类的; 两个方法要同为static或同为非static。

public void method1(String[] str,int age) throws Exception{
}
class Cirlce{
//求圆的面积
public double findArea(){
}
}
class Cylinder extends Circle{
//求圆柱的表面积
public double findArea(){
}
}

2. 关键字super

(1)super,相较于关键字 this,可以修饰属性、方法、构造器。

(2)super 修饰属性、方法:在子类的方法、构造器中,通过 super.属性 或者 super.方法 的形式,显式的调用父类的指定属性或方法。尤其是,当子类与父类有同名的属性、或方法时,调用父类中的结构的话,一定要用 super.

(3)通过 super(形参列表),显式的在子类的构造器中,调用父类指定的构造器。

任何一个类(除Object类)的构造器的首行,要么显式的调用本类中重载的其它的构造器 this(形参列表) 或显式的调用父类中。

指定的构造器 super(形参列表),要么默认的调用父类空参的构造器 super()

建议在设计类时,提供一个空参的构造器!

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

//子类对象实例化的全过程
public class TestDog {
public static void main(String[] args) {
Dog d = new Dog();
d.setAge(10);
d.setName("小明");
d.setHostName("花花");
System.out.println("name:" + d.getName() + " age:" + d.getAge()
+ "hostName:" + d.getHostName());
System.out.println(d.toString());
}
}
// 生物
class Creator {
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Creator() {
super();
System.out.println("this is Creator's constructor");
}
}
// 动物类
class Animal extends Creator {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Animal() {
super();
System.out.println("this is Animal's constructor");
}
}
// 狗
class Dog extends Animal {
private String hostName;
public String getHostName() {
return hostName;
}
public void setHostName(String hostName) {
this.hostName = hostName;
}
public Dog() {
super();
System.out.println("this is Dog's constructor");
}
}

4. 面向对象的特征三:多态性

(1)多态性的表现:①方法的重载与重写 ②子类对象的多态性

(2)使用的前提:①要有继承关系 ②要有方法的重写

(3)格式:

Person p = new Man();//向上转型
// 虚拟方法调用:通过父类的引用指向子类的对象实体,当调用方法时,实际执行的是子类重写父类的方法
p1.eat();
p1.walk();
// p1.entertainment();

(4)编译时,认为 p 是 Person 类型的,故只能执行 Person 里才有的结构,即 Man 里特有的结构不能够调用。

子类对象的多态性,并不使用于属性。

(5)关于向下转型:

①向下转型,使用强转符:()

②为了保证不报 ClassCastException,最好在向下转型前,进行判断: instanceof

// 若a是A类的实例,那么a也一定是A类的父类的实例。
if (p1 instanceof Woman) {
System.out.println("hello!");
Woman w1 = (Woman) p1;
w1.shopping();
}
if (p1 instanceof Man) {
Man m1 = (Man) p1;
m1.entertainment();
}

5. Object类

(1)java.lang.Object 类,是所有类的根父类!

(2)Object类仅有一个空参的构造器 public Object(){ }

(3)关于方法:

①equals(Object obj)

public boolean equals(Object obj) {
return (this == obj);
}

// ==

1.基本数据类型:根据基本数据类型的值判断是否相等。相等返回true,反之返回false 注:两端数据类型可以不同,在不同的情况下,也可以返回true。

2.引用数据类型:比较引用类型变量的地址值是否相等。

//equals():

①只能处理引用类型变量②在Object类,发现equals()仍然比较的两个引用变量的地址值是否相等 像String 包装类 File类 Date类这些重写Object类的equals()方法,比较是两个对象的 //"实体内容"是否完全相同。 若我们自定义一个类,希望比较两个对象的属性值都相同的情况下返回true的话,就需要重写Object类的 equals(Object obj)方法

②toString()方法

  1. 当我们输出一个对象的引用时,会调用 toString() 方法。

    public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    当我们没有重写 Object 类的 toString() 方法时,打印的就是对象所在的类,以及对象实体在堆空间的位置

  2. 一般我们需要重写 Object 类的 toString() 方法,将此对象的各个属性值返回。

  3. 像 String 类、Date、File 类、包装类都重写了 toString() 方法。

6. Junit单元测试类

1) 当前工程下 —> 右键 build path-add libraries-Junit4

2) 在主类中,创建一个空参的无返回值的方法,如:public void test1(),用于代码的测试,方法上声明:@Test

3) 导入 import org.junit.Test

4) 在test()方法中,进行代码的编写

5) 测试:双击方法名,右键 run as-junit Test 即可

import org.junit.Test;
public class TestDemo {
public static void main(String[] args) {
String ss = "hello";
System.out.println(ss);
}
@Test
public void test2(){
System.out.println("test2!!!");
test1();
}
@Test
public void test1(){
String ss = "hello";
System.out.println(ss);
haha();
}
public void haha() {
System.out.println("hahahahha");
}
}

7. 包装类(装箱、拆箱)

基本数据类型由于不是类,不能够使用 java 类库里提供的大量的方法。所有在设计上,我们让每一个基本数据类型都对应一个类,同时数据存储的范围还不变。此时相当于基本数据类型就具有了类的特点,这些类即为包装类(wrapper 或封装类)。

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

简易版:

(1)基本数据类型与对应的包装类有自动装箱、自动拆箱

int i = 10;
Integer i1 = i;//自动装箱
int j = i1;//自动拆箱

(2)基本数据类型、包装类 --> String类:调用 String 类的重载的 valueOf(Xxx xx);

String类 –> 基本数据类型、包装类:调用相应的包装的 parseXxx(String str);

注意:

String str = "123";
int i = (int)str;是错误的转法。
package com.atguigu.java;
import org.junit.Test;
//包装类:8种基本数据类型对应着一个类,此类即为包装类。
//基本数据类型 包装类 及String之间的相互转换
public class TestWrapper {
//基本数据类型、包装类与String类之间的转换
@Test
public void test2(){
//基本数据类型、包装类 --->String类:调用String类的重载的valueOf(Xxx x)方法
int i1 = 10;
String str1 = i1 + "";//"10"
Integer i2 = i1;
String str2 = String.valueOf(i2);
String str3 = String.valueOf(true);//"true"
str2 = i2.toString();
System.out.println(str3);
//String类--->基本数据类型、包装类:调用包装类的parseXxx(String str)方法
int i3 = Integer.parseInt(str2);
System.out.println(i3);
boolean b1 = Boolean.parseBoolean(str3);
System.out.println(b1);
//int i4 = (int)str2;
}
//基本数据类型与包装类之间的转化
@Test
public void test1(){
int i = 10;
System.out.println(i);
boolean b = false;
//基本数据类型--->对应的包装类:调用包装类的构造器
Integer i1 = new Integer(i);
System.out.println(i1.toString());
Float f = new Float("12.3F");
System.out.println(f);
//java.lang.NumberFormatException
//i1 = new Integer("12abc");
//System.out.println(i1);
//对于Boolean来讲,当形参是"true"返回true,除此之外返回false。
Boolean b1 = new Boolean("false");
System.out.println(b1);
b1 = new Boolean("truea");
System.out.println(b1);
Order o = new Order();
System.out.println("$ "+o.b);//null
//包装类--->基本数据类型:调用包装类Xxx的XxxValue()方法。
int i2 = i1.intValue();
System.out.println(i2);
float f1 = f.floatValue();
System.out.println(f1);
boolean b2 = b1.booleanValue();
//JDK5.0以后,自动装箱和拆箱
int i4 = 12;
Integer i3 = i4;//自动装箱
Boolean bb = false;
int i5 = i3;//自动拆箱
}
}
class Order{
Boolean b;
}