Java笔记（第七课)

本节内容:

1：继承:

1:子类继承父类所有的成员变量及其方法,但不继承构造方法

(如果是private可以继承但是也不能调用)

super();只能放在构造函数第一行

调用super，父类必须有无参构造

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Stu a = new Stu(100);
        a.print();
    
    }
}
class Person
{
    Person()
    {
    }
    Person(int age)
    {
        this.age = age;
    }
    int age;
    void print()
    {
        System.out.println(this.age);
        
    }
    
}
class Stu extends Person
{
    Stu(int age)
    {
        super(age);
        
    }
    
}

2:子类构造函数第一行语句必须调用父类的构造方法，且只能是第一行调用.

3:如果显式地调用了父类的构造方法，则不默认调用父类无参的构造方法了

4:java只支持单继承，不支持多继承

class MAfica extend Afica,Asia{}  //会报错

但支持多层继承//用法，在银行程序添加VIP客户(取款函数中最多可透支3000)

class Cust{}
class VIPCust extends Cust
{
  VIPCust(){};
  VIPCust(String name,int ID, int pwd,double m)
  {
    super(name,ID,pwd,m);
  }
}

5:子类中有和父类句柄一模一样的方法，之后如果用子类的对象调用执行该方法，则执行的是子类的代码（方法）.

例如：

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Stu a = new Stu();
        a.print();
    
    }
}
class Person
{
    int age;
    void print()
    {
        System.out.println("I am Person");
    }
}
class Stu extends Person
{
    void print()
    {
        System.out.println("I am student");
    }
}

输出:I am student

2:多态（一种形式多种形态）

1:父类的引用可以无条件指向子类的对象

父类调用的函数的代码是子类的代码

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Stu stu = new Stu();
        stu.print();
        
        Person per = new Person();
        per.print();
        
        Person sp = new Stu();//用父类 new Stu
        sp.print();
       
    
    }
}
class Person
{
    void print()
    {
    System.out.println("Person");
    }
    
}
class Stu extends Person
{
    void print()
    {
    System.out.println("Student");
    }
}

输出:

Student

Person

Student

####

在银行程序中判断是否创建VIP客户（m>3000) ，否则为普通客户

if(m>3000) st.add(new VIPCust());
else st.add(new Cust());

多态的作用是什么？

在Vector中（ 强制）转换类型中防止出错

比如:

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Vector v = new Vector();
        v.add(new A());
        v.add(new B());
        A a = (A)v.get(0);//强制类型转换
        B b = (B)v.get(1);
        a.print();
        b.print();
    }
}
class A
{
    void print()
    {
        System.out.println("A");
    }
}
class B 
{
    void print()
    {
        System.out.println("B");
    }
}

输出：A

B

没有问题，因为你知道a,b是什么类型的，所以可以直接进行转换，而若是:

 B b = (B)v.get(1); 改为  A b = (A)v.get(1);

则会报错

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Vector v = new Vector();
        v.add(new A());
        v.add(new B());
        A a = (A)v.get(0);//强制类型转换
        A b = (A)v.get(1);//变化后的代码
        a.print();
        b.print();
    }
}
class A
{
    void print()
    {
        System.out.println("A");
    }
}
class B 
{
    void print()
    {
        System.out.println("B");
    }
}

报错信息:class B cannot be cast to class A

但若是用到多态，也就是将class B 改为 class B extends A

import java.util.*;
public class Main
{
    public static void main(String[] args)
    {
        Vector v = new Vector();
        v.add(new A());
        v.add(new B());
        A a = (A)v.get(0);//强制类型转换
        A b = (A)v.get(1);
        a.print();
        b.print();
    }
}
class A
{
    void print()
    {
        System.out.println("A");
    }
}
class B extends A
{
    void print()
    {
        System.out.println("B");
    }
}

输出 : A

B

###

回到银行程序，事实上你并不知道这个客户是否是VIP 客户，故在强制转换时可能会报错，所以要用到多态防止错误的发生。

只需将class VIPCust 改为 class VIPCust extends Cust

###

2:调用者和被调用者必须共同遵守某一限定，调用者按照该限定进行方法的调用，被调用者按照该规定进行方法的实现。//还没理解透

###

银行程序的更新已放到gitlab网站上: https://git.acwing.com/kubeilly/javaforstudy/-/tree/master/customer