Java 基础_06_继承、重写、多态

1：继承

Java的一大特色：

   跨平台。

代码的三个特色：

   继承，多态、封装。

1.1、Java对象的组成部分

package cn.domain;

 

public class Person {

    private String name;//这成员变量>属性

    private Integer age;

    private String skinColor;

    public void say() { //方法对外公开提供的服务

        System.err.println("Hello..");

    }

}

1.2、对象之关系

组合：

//计算机类

class Computer{//组合- DIY

    private Cpu cpu;

    private Screen screen;

}

 

class Cpu{

   

}

class Screen{

   

}

 

依赖：

//计算机类

class Computer{//组合- DIY

    private Cpu cpu;

    private Screen screen;

    public void run(){

        //若是一个类，在方法里，使用了另外一个类，此时就是叫：Computer依赖于USB这个类。

        USB usb = new USB();

    }

}

2：继承

   在Java里面一个类继承另外一个类用的是 extends 关键字：

 

从父类中继承的是public、protected的方法与属性：

class Father{

    public String name = "Jack";

    protected String addr = "济南";

    String hobby = "Football";

    private String tel = "12899";

   

    public void say(){

        System.err.println("hi im father..");

    }

   

    protected void hi(){

        System.err.println("hi im father.222.");

    }

   

}

class Child extends Father{

   

}

继承	public	protected	默认
同一个包中	继承	继承	继承
不一样的的包中	继承	继承	不能继承

//若是子类拥有相同 的父类的成员属性与方法则在调用时先调用子类的

class Child extends Father{

    public String name = "Mike";

    protected String addr = "山东";

    String hobby = "MATV";

   

    public void say(){

        System.err.println("hi im child..");

    }

   

    protected void hi(){

        System.err.println("hi im child.222.");

    }

}

3：重写 Overried

子类的方法与父类的方法重名：

  要求：

   1：子类与父类方法重名。

   2：了类的方法与父类的方法的参数类型，顺序，个数 彻底同样。

   3：子类权限修饰符号，不缩小，但能够放大。

4：多态

1：类型转换

   public class Demo03 {

    @Test

    public void test1(){

        //本身的类型=本身的对象

        Dog dog = new Dog();

        //让dog对象赋值给Animal

        Animal a1 = dog;//能够

        //让大类型赋值给小类型,在编译时a1是Animal类型 dog2是Dog小类型，但a1本质就是dog

        Dog dog2 = (Dog)a1;

       

        System.err.println("Over..");

    }

}

class Animal{

   

}

class Dog extends Animal{

   

}

class Cat extends Animal{

   

}

--

    @Test

    public void test1() {

        //父类型的变量= 子类型的实例

        Animal a1 = new Dog();

        Dog dog2 = (Dog)a1;

        System.err.println("over..");

       

        //a2本质是一个动物

        Animal a2 = new Animal();

        //此时会出现运行时错误 - 由于a2本质 是指向的Animal的实例

        Dog dog3 = (Dog) a2;

       

        System.err.println("若是运行出错，则此行代码不显示");

    }

 

2：动态调用

   是指在运行时动态的调用子类的非静态的方法。

 

package cn.demo;

 

import javax.sound.midi.SysexMessage;

 

import org.junit.Test;

 

public class Demo03 {

    @Test

    public void test1() {

        //类型  变量   对象

        Animal a = new Dog();

        a.say();//实例方法【非静态的方法】与对象绑定-动态绑定

        System.err.println(a.name);//Jack - 成员变量 与类型绑定 - 静态绑定

        a.hi();//静态的方法与变量的类型绑定

    }

}

 

class Animal {

    public String name = "Jack";

    public void say(){

        System.err.println("不知道是什么动物");

    }

    public static void hi(){

        System.err.println("hi11111......");

    }

}

 

class Dog extends Animal {

    public String name = "Mary";//成员变量不会覆盖

    @Override

    public void say() {//重写覆盖 - 只有实例方法才会有多态的概念

        System.err.println("wwwwww......");

    }

   

    public static void hi(){

        System.err.println("hi2..............");

    }

}

5：继承与Object类

在Java代码中，java.lang.Object是全部类的最高父类。全部类默认都是这个类的子类。

 

能够经过

   Instanceof – 是否是某种类型

public class Demo03 {

    @Test

    public void test1() {

        Dog xy = new Dog();

        System.err.println("xy是DOg类型的吗："+(xy instanceof Dog));//true

        System.err.println("xy是animal类型的吗："+(xy instanceof Animal));//true

        System.err.println("xy是东西："+(xy instanceof Object));//true

        //在比较时，instanceof比较的对象必需要有继承的关系，不然出错

        System.err.println("xy是cat吗："+(xy instanceof Cat));

    }

}

 

class Animal {

}

 

class Dog extends Animal {

}

class Cat{

   

}

6：从Obejct里面都继承的什么方法

 

全部类，都拥有toString方法，它们是Object类里面继承的。

若是子类没有重写toString方法则调用父类。

 

默认的ObObject类里面的toString显示的是：

   public String toString() {

         类的名称                         @      转成16进制            内部地址值

        return getClass().getName() + "@" + Integer.toHexString(hashCode());

    }

 

对于toString:

  1:全部类都拥有这个方法，继承的。

  2：若是将一个类与字符串串联，默认就调用这个方法。或是输出某个对象默认也调用个方法

 

7：equals

比较两个对象的内部内容是否同样

=-= 是比较两个对象的内存地址是否同样。

 

public class Demo03 {

    @Test

    public void test1() {

        String str1 = new String("Hello");

        String str2 = new String("Hello");

        System.err.println("内存地址是否同样:"+(str1==str2));//false

        System.err.println("里面的内容是否同样："+str1.equals(str2));//true

 

    }

}

 

开发一个本身的对象：

 

在Object类里面源代码是：

     */

    public boolean equals(Object obj) {

        return (this == obj);   - 内部默认依然是比较内存地址

    }

 

  s1.equals(s2);

 

如何才能够比较里面的内容：

package cn.demo;

 

import org.junit.Test;

 

public class Demo04 {

    @Test

    public void test1() {

        Student s1 = new Student("Jack",23);

        Student s2 = new Student("Jack",33);//做业：当age,name彻底 同样才是true不然就false

        System.err.println("两个学生的内存是否同样:" + (s1 == s2));// false

        boolean boo = s1.equals(s2);

        System.err.println("两个学生的内容同样:" + boo);// true

 

        Dog dog = new Dog();

        boo = s1.equals(dog);

        System.err.println(boo);// true | false

    }

}

 

class Student {

    private String name;

    private Integer age;

 

    public Student(String name,Integer age) {

        this.name = name;

        this.age=age;

    }

 

    @Override

    public boolean equals(Object obj) {

        // 1:比较两个对象地址是否同样，若是地址同样，则内容必定同样

        if (this == obj) {

            return true;

        } else {// 再比较里面的内容

            if (obj instanceof Student) {

                Student s2 = (Student) obj;

                if (this.name.equals(s2.name)) {

                    return true;

                } else {

                    return false;

                }

            }else{

                return false;

            }

        }

    }

}

 

class Dog {

 

}