黑马程序员——java学习4(84-106)——面向对象——继承、多态

1、继承extends

复用性提高，让类与类之间产生了关系，也引起了多态。

查阅父类描述，创建子类对象

子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this;

子类要访问父类总的同名变量，用super;

1.1重写（覆盖）

当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子类函数的内容。

如同父类函数被覆盖一样。

注意:

(1)、子类覆盖父类，必须保证子类权限>= 父类权限

(2)、静态只能覆盖静态

与重载比，包括返回值类型都一模一样

1.2构造函数重写

子类所有的构造函数的第一行，都有隐式的super();放在第一行！

父类若无，子类的构造函数必须指定调用某个父类的构造函数

要么有this，要么super只能一个

子类至少有一个构造函数会访问父类的构造函数

2、最终final

修饰符，可类、变量、函数,

被final修饰的类不可被继承，

方法不可被覆写，

变量变常量只能赋值一次成员变量局部变量皆可（记得大写）

内部类定义在类的局部位置上时，只能访问该局部被final修饰的局部变量

3、抽象abstract

修饰符，类、方法

多个类中出现相同方法，但是方法主体不同，则向上抽取，只抽定义，但其还是可以有非抽象方法，甚至可以没有抽象方法，仅为了不让类建对象。

抽象方法必须在抽象类中，类不可被new

抽象类中的抽象方法要被使用，必须由子类覆写起所有的抽象方法后，建立子类对象调用

　　如果子类只覆写了部分抽象方法，那些该子类还是一个抽象类

好处：强迫子类做一些功能

即知道子类会做，但不清楚怎么做，便抽象。

package learn;
abstract class Employee{
    private String name;
    private String num;
    private double pay;
    Employee(String name,String num,double pay){
        this.name=name;
        this.num=num;
        this.pay=pay;
    }
    public abstract void work();
    
}

class Pro extends Employee{
    Pro(String name,String num,double pay){
        super(name,num,pay);            
    }
    public void work()
    {
        System.out.print("Pro work");
    }
}
class Mana extends Employee{
    Mana(String name,String num,double pay){
        super(name,num,pay);
    }
    public void work()
    {
        System.out.print("Mana Work");
    }
    
}
public class AbstractDemo {
    public static void main(String[] args)
    {
        Mana a=new Mana("lisi","ceshi11",40);
        a.work();
        Pro b=new Pro("zhangsan","kaifa1",30);
        b.work();
    }
}

4、模板方法

功能不确定的部分暴露出去由该类的子类去完成。

package learn;

abstract class GetTime{
    public final void getTime(){
        long start=System.currentTimeMillis();
        runcode();
        long end=System.currentTimeMillis();
        System.out.println("毫秒"+(end-start));
    }
    public abstract void runcode();
}
class SubTime extends GetTime{
    public void runcode(){
        for(int i=0;i<1000;i++)
        {
            
        }
    }
}
public class AbstractDemo2 {
    public static void main(String[] args)
    {
        SubTime s=new SubTime();
        s.getTime();
    }
}

5、接口interface

特殊的抽象类，当抽象类中的方法都是抽象的。不可创建对象,子类也需全部覆盖其抽象方法

class用于定义类

interface定义接口

接口中的成员都是public

已默认为:

常量: public static final

方法: public abstract

package learn;
interface Inter{
    public static final int num=3;
    public abstract void show();
}
 class Test1 implements Inter{
    public void show(){    
    }
}
public class InterfaceDemo {
    public static void main(String[] args)
    {
        Test1 x=new Test1();
        System.out.println(x.num);
        System.out.println(Test1.num);
        System.out.println(Inter.num);
    }
}

接口与类之间是实现implements,接口与接口之间是继承,接口间存在多继承, 但还是无法同名不同返回值

interface A{
     
 }
interface B{
     
 }
 
interface C extends A,B{
     
}
class AA{}
class BB extends AA implements A,B{}//多实现方式

接口就是体系以外的功能扩展，基本功能定义在类中

package learn;
abstract class Student{
    abstract void study();
    void sleep()
    {
        System.out.println("sleep");
    }
}
interface Smoking{
    void smoke();
}
class ZhangSan2 extends Student implements Smoking{
    void study(){}
    public void smoke(){}
}
class LiSi extends Student{
    void study() {    
    }
    
}
public class InterfaceTestDemo {

}

6、多态

Animal a=new Cat();//类型提升，向上转型

Cat c=(Cat)a;//向下转型

多态自始至终都是子类对象在做变化

体现：

父类的引用指向了自己的子类对象

父类的引用也可以接受自己的子类对象

前提：必须类与类之间有关系，存在覆盖

好处：提高程序的扩展性

弊端:只能使用父类的引用访问父类中的成员

示例：

package learn;

abstract class Students{
    public abstract void study();
    public void sleep(){
        System.out.println("躺着睡");
    }
}

class BaseStudent extends Students{
    public void study(){
        System.out.println("base study");
    }
    public void sleep(){
        System.out.println("坐着睡");
    }
}

class AdvStudent extends Students{
    public void study(){
        System.out.println("adv study");
    }
}

class DoStudent{
    public void doSome(Students stu)
    {
        stu.study();
        stu.sleep();
    }
}
public class DuoTaiDemo3 {
    public static void main(String[] args) {
        DoStudent ds=new DoStudent();
        ds.doSome(new BaseStudent());
        ds.doSome(new AdvStudent());
    }
}

6.2、多态中成员函数和成员变量

常用：

成员函数，编译时看左边，运行时看右边。

面试：

静态成员函数看左！

成员变量，无论编译和运行，都看左边。

package learn;

class Fu{
    int num=5;
    void method1(){
        System.out.println("fu method1");
    }
    void method2(){
        System.out.println("fu method2");
    }
    static void method4(){
        System.out.println("fu method4");
    }
}
class Zi extends Fu{
    int num=8;
    void method1(){
        System.out.println("zi method1");
    }
    void method3(){
        System.out.println("zi method3");
    }
    static void method4(){
        System.out.println("zi method4");
    }
}
public class DuoTaiDemo4 {
    public static void main(String[] args)
    {
        
//        //输出zi1,fu2,zi3
//        Zi zi=new Zi();
//        zi.method1();
//        zi.method2();
//        zi.method3();
        
//        //编译失败,3找不到，省去最后一次，结果zi1,fu2,
//        Fu f=new Zi();
//        f.method1();
//        f.method2();
//        f.method3();
        
//        //成员变量参考左边
//        Fu f=new Zi();
//        System.out.println(f.num);
//        Zi z=new Zi();
//        System.out.println(z.num);

//        //静态成员变量看左
//        Fu f=new Zi();    
//        f.method4();
//        Zi z=new Zi();
//        z.method4();
    }
}

接口示例-主板与声卡网卡

package learn;
interface PCI{
    public void open();
    public void close();
}

class MainBoard{
    public void run(){
        System.out.println("mainboard run");
    }
    public void usePCI(PCI p)
    {
        //以防空指针报错
        if(p!=null)
        {
            p.open();
            p.close();
        }
    }
}

class NetCard implements PCI{
    public void open(){
        System.out.println("netcard open");
    }
    public void close(){
        System.out.println("netcard close");
    }
}

class SoundCard implements PCI{
    public void open(){
        System.out.println("Soundcard open");
    }
    public void close(){
        System.out.println("Soundcard close");
    }
}

public class DuoTaiDemo5 {
    public static void main(String[] args) {
    MainBoard mb=new MainBoard();
    mb.run();
    mb.usePCI(null);
    mb.usePCI(new NetCard());
    mb.usePCI(new SoundCard());
   }
}

6.3、instanceof

判断一个对象到底是那个类的实例

对象 instanceof 类，返回值为boolean

7、object类

所有对象的间接父类。

其中方法多被重写使用

7.1、equals

boolean equals(Object obj)

package learn;
class Demo{
    private int num;
    Demo(){//重载
        
    }
    Demo(int num){
        this.num=num;
    }
    public boolean equals(Object obj){//Object obj=new Object();
        if(!(obj instanceof Demo))
            return false;
        //多态-向下转型
        Demo d=(Demo)obj;
        return this.num==d.num;
    }
}
class Person{
    
}
public class ObjectDemo {
    public static void main(String[] args) {
        Demo d1=new Demo();
        Demo d2=new Demo();
        System.out.println(d1.equals(d2));
        Demo d3=new Demo(4);
        Demo d4=new Demo(5);
        Person p=new Person();
        System.out.println(d3.equals(p));
}
}

7.2、toString

其实就是返回一个字符串，该字符串由类名+@+此对象哈希码的无符号十六进制表示组成。

getClass().getName() + '@' + Integer.toHexString(hashCode())

public class ObjectDemo {
    public static void main(String[] args) {
//        Demo d1=new Demo();
//        Demo d2=new Demo();
//        System.out.println(d1.equals(d2));
//        Demo d3=new Demo(4);
//        Demo d4=new Demo(5);
//        Person p=new Person();
//        System.out.println(d3.equals(p));
        Demo d1=new Demo(4);
        Class c=d1.getClass();
        System.out.println(c.getName());
        System.out.println(Integer.toHexString(d1.hashCode()));
        System.out.println(d1.toString());
}
}