java面向对象(中）

super关键字

1.理解

super理解为父类的
可以用来调用：属性，方法，构造器

2.super的使用

1.我们可以在子类的方法或者构造器中，通过使用"super.属性"或者"super.方法"的方式，显式地调用父类中声明地属性或方法。
2.特殊情况，当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式地使用"super.属性"的方式。
3.特殊情况，当子类重写了父类中地方法以后，我们要想在子类的方法中调用父类中被重写的方法时，则必须显式地使用"super.属性"的方式。

3.super调用构造器

1.我们可以在子类的构造器中显式的使用“super(参数列表)”的方式，调用父类中声明的指定的构造器。
2.“super(参数列表)”的使用必须声明在子类构造器的首行。
3.在类的构造中，针对于“this(参数列表)”或“super(参数列表)”只能二选一。
4.在构造器的首行，没有显式的声明“this(参数列表)”或“super(参数列表)”，则默认调用的式父类中空参的构造器。

多态性

1.笔记

理解多态性

可以理解为一个事物的多种形态

对象的多态性

父类的引用指向子类的对象

多态的使用

虚拟方法调用

• 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法
• 但在运行期，实际执行的是子类重写父类的方法。

多态性的使用前提

• 类的继承关系
• 方法的重写
• 对象的多态性，只适用于方法，不适用于属性
• 多态性是运行时行为

小结：方法的重载和重写

从编译和运行的角度看：
重载，这些同名方法对于编译器而言是不同的方法，它们的调用地址在编译期就绑定了。
而对于多态，只有等到方法调用的那一刻，解释运行器才会确定要调用的具体方法。

2.代码

package com.atguigu.java4;
public class PersonTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.eat();

        Man man = new Man();
        man.eat();
        man.age = 25;
        man.earnmoney();
        //对象的多态性：父类的引用指向子类的对象，Man是Person的子类
        Person p2 = new Man();
        //多态的使用：当调用父类同名同参数的方法时，
        //实际 执行的是子类重写父类的方法---虚拟方法使用
        p2.eat();
        p2.walk();
    }
}

package com.atguigu.exer;

public class FieldMethodTest {
    public static void main(String[] args){
        Sub s = new Sub();
        System.out.println(s.count);//20
        s.display();//20
        Base b = s;
        //对于引用数据来讲，比较的是两个引用数据类型变量的地址是否相同
        System.out.println(b == s);//true
        System.out.println(b.count);//10,多态只适用于方法，不适用于属性
        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);
    }
}

== 和 equals()区别

1. ==：运算符

1.可以使用在基本数据类型变量和引用数据类型变量中
2.如果比较的是基本数据类型，比较两个变量保存的数据是否相等。（不一定类型要相同）
如果比较的是引用数据类型，则比较地址值是否相同，即两个引用是否指向一个对象实体。

2、equals()

1.是一个方法，而非运算符。
2.只能适用于引用数据类型
3.Object类中equals()的定义
public boolean equals(Object obj) {
return (this == obj);
说明：object类中定义的equals()和==定义的作用是相同的。
4.像string、Date.file、包装类都重写了equals()方法，重写以后，比较的是两个对象的“实体内容" 是否相同。
5.通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的“实际内容” 是否相同，需要重写equals()。

3、代码

//EqualsTest.java:
package com.atguigu.java;

import java.util.Date;

/*
*
*
* 面试题：== 和 equals()区别
* 一。==：运算符
* 1.可以使用在基本数据类型变量和引用数据类型变量中
* 2.如果比较的是基本数据类型，比较两个变量保存的数据是否相等。（不一定类型要相同）
*   如果比较的是引用数据类型，则比较地址值是否相同，即两个引用是否指向一个对象实体
*二。equals
* 1.是一个方法，而非运算符
* 2.只能适用于引用数据类型
* 3.Object类中equals()的定义
*   public boolean equals(Object obj) {
*       return (this == obj);
*       说明：object类中定义的equals()和==定义的作用是相同的
*4.像string、Date.file、包装类都重写了equals()方法，重写以后，比较的是两个对象的“实体内容"
* 是否相同
* 5.通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的“实际内容”
* 是否相同，需要重写equals()
* */
public class EqualsTest {
    public static void main(String[] args) {

        int i = 10;
        int j = 10;
        double d = 10.0;
        System.out.println(i == j);//true
        System.out.println(i == d);//true

        boolean b = true;
//        System.out.println(i == b);//不能编译

        char c = 10;
        System.out.println(i == c);//true

        char c1 = 'A';
        char c2 = 65;
        System.out.println(c1 == c2);

        //引用类型
        Customer cust1 = new Customer("TOM",21);
        Customer cust2 = new Customer("TOM",21);
        System.out.println(cust1 == cust2);//false

        String str1 = new String("nnn");
        String str2 = new String("nnn");
        System.out.println(str1 == str2);//false
        System.out.println(str1.equals(str2));//true

        System.out.println(cust1.equals(cust2));//重写之后为true

        Date date1 = new Date(322222L);
        Date date2 = new Date(322222L);
        System.out.println(date1 == date2);//false


    }
}

//Customer.java:
package com.atguigu.java;

import java.util.Objects;

public class Customer {
    String name;
    int age;

    Customer(String name,int age) {
        this.age = age;
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
    //右键generate可自动生成equals和hashcode方法

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Customer customer = (Customer) o;
        return age == customer.age && Objects.equals(name, customer.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
//手写
//    public boolean equals(Object obj) {
//        if(this == obj) {
//            return true;
//        }
//        if(obj instanceof Customer) {
//            Customer cust = (Customer) obj;
//            //比较两个对象的属性是否相同
//            //注意string是引用对象
//            if(this.age == cust.age && this.name.equals(cust.name)) {
//                return true;
//            }else {
//                return false;
//            }
//        }
//        return false;
//    }
    
}

包装类

使用

package com.atguigu.java;
/*
*
* 包装类的使用：
* 1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
* 2、基本数据类型、包装类、String三者之间的相互转换
*
*
* */
public class WrapperTest {
    public static void main(String[] args) {
        //基本数据类型、包装类---》String类型
        //方式1：连接运算
        int number1 = 10;
        String str = number1 + "";
        //方式2：valueOf
        float fl1 = 12.3f;
        String str2 = String.valueOf(fl1);

        //String类型---》基本数据类型、包装类:调用包装类的parsexxx(String s)
        String str1 ="123";
        Integer.parseInt(str1);

        Boolean bol1 = Boolean.parseBoolean(str1);

        //JDK 5.0新特性：自动装箱和拆箱
        int i2 = 10;
        Integer int_1 = i2;//自动装箱

        //基本数据类型--->包装类，调用包装类构造器
        int num1 = 10;
        Integer in1 = new Integer(num1);
        System.out.println(in1.toString());

        Integer in2 = new Integer("123");
        System.out.println(in2.toString());

//        Integer in3 = new Integer("abc123");//报异常
//        System.out.println(in3.toString());

        Float f1 = new Float(12.3f);
        Float f2 = new Float("1.23");

        Boolean b1 = new Boolean("true");
        Boolean b2 = new Boolean("true124");//false

        Order o1 = new Order();
        System.out.println(o1.isMale);//false
        System.out.println(o1.isFemale);//null

        //包装类-->基本数据类型，调用包装类的xxvalue
        Integer int1 = new Integer(12);

        int i1 = int1.intValue();
        System.out.println(i1 + 1);

    }
}
class Order {
    boolean isMale;
    Boolean isFemale;
}

习题

package com.atguigu.java;

public class InterviewTest {
    public static void main(String[] args) {
        //三元运算两个类型要统一
        Object o1 = true ? new Integer(1) : new Double(2.0);
        System.out.println(o1);//1.0

        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内部定义了IntegerCache结构，其中定义了Integer[]，保存了-128到127内的整数，
        //如果我们使用自动装箱的方式，给Integer赋值的范围在它之内，可以直接使用数组中的元素
        //不用再new ,可以提高效率
        Integer x = 128;
        Integer y = 128;
        System.out.println(x == y);//false
    }

}

package com.atguigu.java4;

import java.sql.SQLOutput;
import java.util.Scanner;
import java.util.Vector;

/*
*
* 利用Vector代替数组处理：从键盘读入学生成绩（以负数代表输入结束），找出最高分，
* 并输出学生成绩等级。
    提示：数组一旦创建，长度就固定不变，所以在创建数组前就需要知道它的
    长度。而向量类java.util.Vector可以根据需要动态伸缩。
    创建Vector对象： Vector v=new Vector();
    给向量添加元素： v.addElement(Object obj); //obj必须是对象
    取出向量中的元素： Object obj=v.elementAt(0);
    注意第一个元素的下标是0，返回值是Object类型的。
    计算向量的长度： v.size();
    若与最高分相差10分内： A等； 20分内： B等；
    30分内： C等；其它： D等
*
* */
public class ScoreTest {
    public static void main(String[] args) {
        //1.实例化Scanner ，用于从键盘获取学生成绩
        Scanner scan = new Scanner(System.in);

        //2.创建vector对象
        Vector v = new Vector();
        //3.向vector中添加数组
        int maxscore = 0;
        for(;;) {
            System.out.println("请输入学生成绩（以负数代表输入结束）");
            int score = scan.nextInt();
            if(score < 0) {
                break;
            }
            if(score > 100) {
                System.out.println("数据非法，请重新输入");
                continue;
            }
            //jdk5.0之前
//            Integer inscore = new Integer(score);
//            v.addElement(score);
            //jdk5.0之后
            v.addElement(score);//自动装箱
            //4.获取成绩最大值
            if(score > maxscore) {
                maxscore = score;
            }
        }
        //5.划分等级
        char level;
        for(int i = 0; i < v.size(); i++) {
            Object obj=v.elementAt(i);
            //jdk5.0之前
            Integer inscore = (Integer) obj;
            int score = inscore.intValue();
            if(maxscore - score <= 10) {
                level = 'A';
            }else if(maxscore - score <= 20){
                level = 'B';
            }else if(maxscore - score <= 30) {
                level = 'C';
            }else {
                level = 'D';
            }
            System.out.println("student-" + i + "score is "+ score +",level is " + level);
        }

    }
}