Java-05面向对象（中）

一、面向对象的特征：继承

1、继承作用

继承的出现减少了代码冗余，提高了代码的复用性。

继承的出现，更有利于功能的扩展。子类不是父类的子集，而是对父类的“扩展”。 

继承的出现让类与类之间产生了关系，提供了多态的前提。 单层继承和多层继承

子类不能直接访问父类中私有的(private)的成员变量和方法 ，但是是有继承的，只是访问不了

子类不能继承父类的构造方法【其他函数都可以通过类对象来调用，但是构造函数是用来产生对象的函数，它在对象之前。 而继承对对象来说是能够调用父类的函数，但是对象都不存在你还调用什么父类的构造函数？ 所以构造函数无法继承。】

2、方法重写

1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型【基本数据类型和void类型，子类与父类一致，引用数据类型，子类不大于父类】

3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限

　子类不能重写父类中声明为private权限的方法、静态方法【静态方法可以被继承，但是不能被覆盖重写。如果父类中定义的静态方法在子类中被重新定义，那么在父类中定义的静态方法将被隐藏。可以使用语法：父类名.静态方法调用隐藏的静态方法。

　　　　　　　　　　　　　　　　　　　　　　　　　　　该子类实际上只是将父类中的该同名方法进行了隐藏，而非重写。换句话说，父类和子类中含有的其实是两个没有关系的方法，它们的行为也并不具有多态性
　　　　　　　　　　　　　　　　　　　　　　　　　　　　因此，通过一个指向子类对象的父类引用变量来调用父子同名的静态方法时，只会调用父类的静态方法】

4. 子类方法抛出的异常不能大于父类被重写方法的异常 

3、super关键字

super可用于访问父类中定义的属性 

super可用于调用父类中定义的成员方法 

super可用于在子类构造器中调用父类的构造器，子类隐式调用父类无参构造器

this和super使用规则类型

在同一个构造器中，this调用本类构造和super调用父类构造只能2选1，不能同时存在

如果子类构造器中既未显式调用父类或本类的构造器，且父类中又 没有无参的构造器【需要显式调用】，则编译出错 ,总而言之，子类一定会调用父类的构造方法

二、面向对象的特征：多态

1、多态：一个事物的多种形态，父类引用指向子类对象

2、多态前提：继承

3、对象的多态使用：编译期只能调用父类有声明过的方法，执行期调用子类重写父类的方法，编译看左边，执行看右边，对象多态性只适用方法，不适用属性（编译，执行都看左边）

4、多态性是运行期行为，只有运行的时候才知道调用哪个对象

public class Test {
    public static void main(String[] args) {
        func(new Cat());
        func(new Dog());
    }
    public static void func(Animal animal){//Animal animal = new Cat()多态
        animal.eat();
        animal.shout();
    }
}

 class Animal {
    public void eat(){
        System.out.println("动物：进食");
    }
    public void shout(){
        System.out.println("动物：叫");
    }
}

 class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println("狗吃骨头");
    }
    @Override
    public void shout(){
        System.out.println("汪！汪！汪！");
    }
}
 class Cat extends Animal {
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
    @Override
    public void shout(){
        System.out.println("喵！喵！喵！");
    }
}

5、向下转型

向上转型时，堆空间是加载子类的属性和方法，但是编译看左边，不能直接调用子类特有的方法和属性需使用“多态向下转型”

关键字instanceOf

public class Test {
    public static void main(String[] args) {
        Base base = new Sub();
        base.add(1,2,3);//sub1
        Sub sub = (Sub)base;
        sub.add(1,2,3);//sub2

    }
}

  class Base {
    public void add(int a ,int...arr){
        System.out.println("base");
    }

}
 class Sub extends Base{
    public void add(int a,int[] arr){//重写base的add方法
        System.out.println("sub1");
    }
    public void add(int a,int b,int c){//没有重写base的add方法
        System.out.println("sub2");
    }

}

 三、object和包装类

 tostring和equals方法重写

Java提供了8种基本数据类型的包装类，使得基本数据类型变量有类的特征

基本数据类型，string，包装类相互装换

public class Test {
    public static void main(String[] args) {
        int  num =10;
//        Integer integer = new Integer(num);//过时
        Integer integer = num;//自动装箱
        System.out.println(integer);
        num=integer.intValue();//自动拆箱
        int sum = num+10;
        System.out.println(sum);
        System.out.println("===========");
//        以下两种都可以编译通过：JDK5.0之后，有了新特性，自动装箱，拆箱，不用new
        method(num);//10
        method(integer);//10
    }
    public static void method(Object obj){
        System.out.println(obj);
    }
}

//java.lang.String包下的静态方法valueOf（基本数据类型/包装类）方法
public class Test {
    public static void main(String[] args) {
//        包装类，基本数据类型--→string
        int num1 = 10;
        Integer integer = num1;
//        方式1：运算
        String str1 = num1+"";
        System.out.println(str1);//10
//        方式2：public static String valueOf()方法
        String str2 = String.valueOf(num1);
        System.out.println(str2);//10
        String str3 = String.valueOf(integer);
        System.out.println(str3);//10
//      string--→包装类，基本数据类型
        String str4 ="123";
        Integer integer1 = new Integer(str4);
        System.out.println(integer1+10);//133
        int num2 = Integer.parseInt(str4);
        System.out.println(num2);//123
        String s = "false";
        boolean b = Boolean.parseBoolean(s);
        System.out.println(b);
        //除了整型，布尔值，其他类型跟string进行转换会报错
//        double d = Double.parseDouble(s);//报错


    }
}

面试题

Object o1 = true ? new Integer(1) : new Double(2.0); 
System.out.println(o1);//1.0自动提升到double

Object o2;
 if (true)
o2 = new Integer(1); 
else
o2 = new Double(2.0); 
System.out.println(o2);//1

public 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);//true

Integer x = 128;
Integer y = 128; 
System.out.println(x == y);//false，包装类定义了一个数组，保存-128到127的整数，如果在其范围内，可以直接这范围内的数，超出了则new了对象
}

练习

利用Vector代替数组处理:从键盘读入学生成绩(以负数代表输入结束)，找出 最高分，并输出学生成绩等级。 

若与最高分相差10分内:A等;20分内:B等;30分内:C等;其它:D等 

import java.util.Scanner;
import java.util.Vector;

public class Test{
    public static void main(String[] args) {
        Vector vector = new Vector();
        int max = 0;
        while(true){
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入学生成绩：");
            int score=scanner.nextInt();
            if(score<0) {
                break;
            }
            if(score>100){
                System.out.println("数据输入有误，请重新输入：");
                continue;
            }
            vector.add(score);
            max = max>score?max:score;

        }
        System.out.println("最大值："+max);
        for (Object i:vector) {
            int j = (Integer)i;//obj转integer再转int
            if(max-j<=10){
                System.out.println("A");
            }else if(max-j<=20){
                System.out.println("B");
            }else if(max-j<=30){
                System.out.println("C");
            }else{
                System.out.println("D");
            }
            
        }

    }
}

 

四、测试单元（interllij idea下）