Java 封装继承多态抽象类接口

初始化对象（构造方法）

• 不能被任何返回值类型和void修饰

• 构造方法的方法名和类名相同

• this来调用本类中其它构造方法

• 每个类默认有个无参构造方法，若定义有参构造方法，无参的就被清除，若既要使用无参又要使用有参构造方法，必须定义无参构造方法

  public 类名(参数值){
      this.属性=属性名;
  }

• A类的构造方法不能在不能在B类的构造方法中调用

  封装

  • 私有化属性：用getter和setter方法来获取和初始化属性

  • 私有化方法：若私有化方法A，可在另一个public方法B里面调用A方法

  继承

  在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

  子类只能继承父类的非私有化方法和属性

  静态方法，私有化属性，构造方法都继承不了

  public class Fu {
  }
  ​
  //实现继承关系 extends
  class Zi extends Fu{
      
  }

  特点

  • 在java中只有单继承，一个子类不能继承多个父类

  • 但是可以传递继承AextendsB，BextendsC，相当于A继承了B，C

  • 在子类构造方法调用父类有参构造方法时必须通过super(参数)来调用父类有参构造方法，无参构造方法自己调用

public class Fu {
    static {
        System.out.println(1);
    }
    {
        System.out.println(2);
    }
    public Fu(){
        System.out.println(3);
    }
​
}
public class Zi extends Fu {
​
    static {
        System.out.println(4);
    }
    {
        System.out.println(5);
    }
    public Zi(){
        System.out.println(6);
    }
}
public class Test{
    public static void main(String[] args) {
        // 说明在java里面创建子类对象会去调用父类的无参构造方法。
        //先执行的父类的构造方法
        Zi zi = new Zi();
​
    }
}

调用顺序为1-4-2-3-5-6

方法的重写/覆盖----override

两个存在继承关系的类，方法体和访问权限可以不一样，其余方法的结构必须和父类的方法以某一样（方法名和参数列表）

代码块上有@override，说明必是继承父类

• 如果父类的方法是静态方法，不算重写但可调用子类方法

• 子类重写后的方法后的访问权限一定要大于父类的访问权限

  如果父类的访问权限是protected那么子类重写以后是protected和public，如果父类是public，子类只能是public，若同包下父类是缺省的，那他的子类可以是缺省的，protected，public。

  private不能被重写

  final

  修饰属性:

  • 全局属性

    若全局属性被final修饰，这个属性就变成常量，必须给定初始值

    public class Zi{
        //方法1
        public final int a = 10;
        //方法2
        public final int b;
        {
            b = 12;
        }
    }

  • 静态全局常量

    可以在定义这个常量的时候给定初始值，也可以在静态代码块里面给定初始值

public class Zi extends Fu {
    //方法1
    public static final int a = 10;
    //方法2
    public static final int b;
   
    static {
        b = 15;
    }
}

• 局部属性

要在使用前定值，定植后不能再改变

修饰方法

不能被子类方法重写

修饰类

说明这个类是一个最终的类，也就是不能被其它类所继承

this和super

this指代的是当前类的对象

super指代的是父类对象

属性

当子类和父类属性名相同时

super.属性：调用父类属性

this.属性：调用子类属性

方法

当子类和父类方法名相同时

super.方法名(参数名)：调用父类方法

this.方法名(参数名)：调用子类方法

构造方法

如果在一个类里面，在这个类的某一个构造方法里面需要调用本类的其它构造方法this(参数)，如果想要在子类的构造方法里面调用父类的构造方法需要通过super(参数)

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

条件

• 继承

• 重写父类方法

• 父类引用子类对象，通过子类创建父类对象

  Fu fu = new Zi();

向上转型和向下转型

父类范围较大，子类范围较小

父类转为子类是向下转型，子类转为父类是向上转型

多态属于向上转型

向下转型的方法是在对象前面加一个小括号，括号里面的是你想转化的类型

(Dog)anaimal

instanceof

如果这个类是这个类的子类或自己本类（实例化对象），则返回true，反之返回false

向上转型（多态）：

只要A类是B类的子类，那么B类对象就能通过A类来创建

向下转型：

只要A类是B类的子类，并且B类对象是通过A类或者A类的子类来创建的，那么B类对象就能向下转型成A类的对象。

class A {
    public String show(D obj) { //方法一
        return ("A and D");
    }
​
    public String show(A obj) { //方法二
        return ("A and A");
    }
​
}
​
class B extends A {
    public String show(B obj) { //方法三
        return ("B and B");
    }
​
    public String show(A obj) { //方法四
        return ("B and A");
    }
}
class C extends B {
}
class D extends B {
}
public class Test1 {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        System.out.println("7--" + b.show(b));//B and B
        System.out.println("9--" + b.show(d));//A and D
        System.out.println("3--" + a1.show(d));//A and D
        System.out.println("1--" + a1.show(b));//A and A
        System.out.println("5--" + a2.show(c));//B and A
        System.out.println("8--" + b.show(c));//B and B
        System.out.println("4--" + a2.show(b));//B and A
        System.out.println("2--" + a1.show(c));//A and A
        System.out.println("6--" + a2.show(d));//A and D
    }
​
}

抽象类

在class前面加abstract

抽象类A

public abstact A{
    //
}

• 抽象类不能被final修饰

• 不能创建抽象类的对象

• 抽象类存在构造方法，但没有抽象构造方法

创建构造类的对象只能通过向上转型（多态）来实现

1. 使用匿名内部类

2. 创建一个抽象类的子类

Test1 test1=new x();
@Override
public void a() {
    
}

一个抽象类的子类去实现抽象类，如果这个子类还是抽象类，则可以不完全实现父类的所有抽象方法，若是一个非抽象类就必须要实现所有抽象方法，而使用匿名内部类实现也需要实现所有的抽象方法

1 对于实现类来继承抽象类，在实现类里面必须实现所有的抽象方法

2 抽象方法：方法被abstract修饰，且没有方法体

3 抽象方法必须处于抽象类中

4 抽象方法不能被private，final，static修饰

public abstract class Animal {
    
    //定义一个抽象方法
    //无返回值
    public abstract void eat();
    //有返回值
    public abstract int add();
    //带参数的抽象方法
    public abstract int add(int i,int j);
    //权限修饰符 private不能修饰抽象方法，因为抽象方法本身就是让子类去实现（重写）
    //final 不能修饰抽象方法
    //public static abstract int add1(int i,int j);
    //static:也不能修饰方法。
    // 因为如果一个方法被static修饰，那么这个方法直接可以通过类名去调用
    //public static abstract int del();
    //在抽象类里面可以存在普通方法
    public static final void a(){
        
    }
}

接口

通过interface关键字来实现接口

public interface A{
    //A接口
}

1. 接口中只能存在抽象方法

2. 没有构造方法

3. 接口中所有的属性都是常量

4. 权限修饰符只能是public

属性：公共的静态常量，定义属性时会默认为public

方法：公共方法，若没有加abstract在编译后会默认加上

接口和接口之间是多继承，

类只能去实现接口，可以多实现；通过implements来实现

使用场景：

(1) 接口为核心，定义要完成的任务，没有具体化定义如何实现

(2) 若实现接口的某些类有共同的方法，则抽象出来一个抽象类

(3) 其余多个类去继承这个抽象类

标识接口

Serializable：如果一个类实现这个Serializable，说明这个类可以被序列化

Cloneable：如果一个类想去实现克隆，那么这个类必须实现Cloneable，如果不是实现这个标识接口，你克隆会报错的。

RandomAccess：实现了这个接口，说明随机访问比较块