第四章：Java_面向对象编程（二）

野性酷女 2022-07-12 04:47 181阅读 0赞

**目录：**

> 1.  面向对象的特征之二：继承性  
>     
>     
>      *  方法的重写
> 2.  关键字super
> 3.  子类对象实例化的全过程
> 4.  面向对象的特征之三：多态性  
>     Object类  
>     Junit单元测试类  
>     包装类

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

1.为什么要有继承性：  
![这里写图片描述][SouthEast]

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");
        }
    
    }

![这里写图片描述][SouthEast 1]

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

![这里写图片描述][SouthEast 2]

--------------------

# 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()方法**  
当我们输出一个对象的引用时，会调用toString()方法。

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

当我们没有重写Object类的toString()方法时，打印的就是对象所在的类，以及对象实体在堆空间的位置  
2.一般我们需要重写Object类的toString()方法，将此对象的各个属性值返回。  
3.像String类、Date、File类、包装类都重写了toString()方法。

# 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");
        }
    }

# 包装类(装箱、拆箱) #

> 基本数据类型由于不是类，不能够使用java类库里提供的大量的方法。所有在设计上，我们让每一个基本数据类型都对应一个类，同时数据存储的范围还不变。此时相当于基本数据类型就具有了类的特点。这些类即为包装类（wrapper 或封装类）  
> ![这里写图片描述][SouthEast 3]

**基本数据类型、包装类、String类之间的转换！**  
![这里写图片描述][SouthEast 4]

**简易版：**  
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;
    }

[SouthEast]: /images/20220711/a8e719585d5a4eefb2e686e203456e0b.png
[SouthEast 1]: /images/20220711/9414ec78dfef415fbb290597acce53a5.png
[SouthEast 2]: /images/20220711/04d71aefe2ba4b29b51a8f14ce0a6cb0.png
[SouthEast 3]: /images/20220711/2db3a44716eb4093b9813b94296870be.png
[SouthEast 4]: /images/20220711/13d68ca275664b4f8baedd6ac4bdfb34.png

第四章：Java_面向对象编程（二）

发表评论取消回复

还没有评论，来说两句吧...

相关阅读