JAVA OOP第二课

一、继承：extends

1、概念

1、概念：子类继承父类，在每一个子类对象中都有一个独立的父类对象。

//子类KBStudent继承了父类Student
public class KBStudent extends Student {
   
 }

1）this是当前对象，this（参数列表）在当前类的构造方法中调用其他重载构造。

//非全参构造
 public Student(String stuNo,String stuName,char gender){
        this.stuNo = stuNo;
        this.stuName = stuName;
        this.gender = gender;
    }
//全参构造
public Student(String stuNo,String stuName,char gender,int age,String product){
        this(stuNo, stuName, gender);
        //在当前类的全参构造中调用了非全参的重载构造
        this.age = age;
        this.product = product;
    }

2）super是父类对象，super(参数列表)在子类构造中调用父类的构造。

public class KBStudent extends Student {
    private double expectSalary;

    public KBStudent() {}

    public KBStudent(String stuNo, String name, int age, char gender, String qualification, String major,double expectSalary) {
        super("课工场大数据", stuNo, name, age, gender, qualification, major);
        this.expectSalary = expectSalary;
    }

3）this()或者super()必须位于当前构造方法的第一句。
2、继承是一种高级封装。
3、不能继承父类的内容：
1）私有的private
2）构造方法(Constuctor)
3）非同包父类受保护类型protected
4、通过访问修饰符和包进行访问权限控制

访问修饰符	类内	同包	不同包子类	其他
private	*
default	*	*
protected	*	*	*
public	*	*	*	*

5、三种方法代码块比较
构造方法<普通代码块<静态代码块

 static {
        for (int i = 0; i <4 ; i++) {
        }
        int a = 7;
        System.out.println("父类静态代码块");
    }

    {
        int a = 7;
        System.out.println("父类普通代码块");
    }

    {
        int a = 7;
    }

    public Father(){
        System.out.println("父类构造方法");
    }


结果如下：

父类静态代码块
父类普通代码块
父类构造方法

2、static:

（1）被static修饰的属性和方法称之为类属性和类方法，无需对象，通过类名就可以直接访问。

package lian;

public class Lianxi02 {
    private static String  stuNo;
    private String stuName;


    public static void main(String[] args) {
        Lianxi02.stuNo = "123";  //stuNo 被static修饰，所以访问时就可以直接通过类名Lianxi02直接访问
        Lianxi02 s = new Lianxi02();  //而stuName没有被static修饰，所以访问时需要新建对象，通过对象s访问
        s.stuName = "123";
    }    
}

（2）JVM启动时装载字节码文件过程中创建所有静态内容，当JVM关闭时static内容才会被销毁。
（3）当属性和方法使用率较高时，且当前工程中许多类需要使用时，用static修饰属性和方法，避免每调用一次属性或者方法都去创建一个对象。
（4）静态方法只能访问静态属性和静态方法。

  private static String  stuNo;
    private String stuName;
    private  char gender;


    public static String getStuNo() {
        return stuNo;
    }

    public static void setStuNo(String stuNo) {
        Lianxi02.stuNo = stuNo; // 静态方法访问静态属性
        this.stuName = stuName; 
        // 报错：Non-static field 'stuName' cannot be referenced from a static context ，静态方法不能访问非静态属性
        
    }

3、重写

（1）重写：子类重写父类同名、同参、同返回值的方法。

4、转型

概念

1、概念：有继承关系的对象类型转化。
2、自动类型转化：父类引用指向子类对象。
3、强制类型转化：不是将父类对象转化为子类对象，而是通过instanceof运算符判定父类引用指向子类对象的实际类型；否则会导致类型转化异常。报错：java.lang.ClassCastException

public class Lianxi03 {
    public static void main(String[] args) {
        List array = new ArrayList();
        array.add(123);
        array.add('男');
        array.add(1,"张三");
        array.add("李四");

		Object s = ((ArrayList) array).clone();  //强制类型转换
        System.out.println(s);
  }

5、多态

1、一种类型多种表现形式。
2、继承
3、重写
4、实际方法：一个父类有多个子类，在构造方法时以 父类的引用作为形参，在调用时，传入不同子类对象实参。

二、抽象类：abstract

1、可以有抽象方法，由abstract修饰的方法，只能做方法的声明，不能做方法的实现。

package lian;

public abstract class Lianxi04 {
    private String stuName;
    private String stuNo;
    private int age;

	//抽象方法只做声明，不做实现
    public abstract String getStuName(); 

    public abstract String getStuNo(); 
    
}

package lian;

public class Test extends Lianxi04 {
	//子类继承父类，对其抽象方法进行重写。
    @Override
    public String getStuName() {
        return null;
    }

    @Override
    public String getStuNo() {
        return null;
    }
}

2、子类必须重写抽象父类中的抽象方法，除非子类也是抽象类。
3、抽象类不可以直接实例化。

package lian;

public class Test extends Lianxi04 {
    Lianxi04 ss = new Lianxi04();
	//报错：'Lianxi04' is abstract; cannot be instantiated
	//Lianxi04为抽象类，不可以实例化
}

三、接口：interface

1、方法默认为公共的抽象方法，属性默认为公共的静态常。
2、子类必须实现父类接口中的所有抽象方法，除非子类是接口或者抽象类；接口与接口之继承用extends。

package mgr;

public interface ArrayList {
    void add(String name);
    void remove(String name);
    void show();

}

package mgr;

//子类ClassMgr继承父类接口ArrayList,子类必须声明与实现父类接口的方法。

public class ClassMgr implements ArrayList{
    @Override
    public void add(String name) {
    }

    @Override
    public void remove(String name) {
    }

    @Override
    public void show() {
    }

3、接口不可以直接实例化。
4、作用：
（1）同步开发，定交换标准。
（2）隐藏实现。
5、接口与父类的 差别：
（1）单继承：一个子类只能继承一个父类。
（2）多实现：一个子类可以继承多个父类接口，
（3）父子关系：

四、泛型

1、引用类型参数化。

package kb08.util;
//类级泛型
public interface List<T> extends Iterable <T> {
	 int size();
	 boolean isEmpty();
	 Object[] toArray();
 }
	 

2、类级泛型
3、方法级泛型