Java面向对象特征

封装

private int age（私有 类名称 属性名称）。特别注意的是数组也属于java类。private 可以封装类、属性、方法。

继承

1、子类可以直接继承父类的操作，并且子类还可以继续扩充自己的功能。

package practice;
class A{
    private String name;
    private int age;
    
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name ;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }
}
class B extends A{
    private String school;
    public void setSchool(String school){
        this.school = school;
    }
    public String getSchool(){
        return this.school;
    }
}
public class exte {
    public static void main(String [] args){
        A a = new A();
        B b = new B();
        a.setName("张三");
        a.setAge(23);
        b.setSchool("大学也");
        System.out.println("姓名："+a.getName()+",年龄："+a.getAge()+"，学校："+b.getSchool());
    }
}

2、Java不允许多重继承，允许多层继承。

//此为错误继承
class A{
}
class B{
}
class C extends A,B{
}
//这是对的
class A{
}
class B extends A{
}
class C extends B{
}

3、子类构造调用一定会先执行父类操作，显式/隐式操作

package practice;
class A1{
    private String name;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}
class B1 extends A1{
      /*public void fun(){
  System.out.println(name);    //这里用super.name调用也不对，私有属性只能在本类使用，父类不可使用
}   */      //此方法操作错误，B1的name隐式继承乐A1的name，不能直接对私有属性进行操作，而可以隐式继承
}
//可以这样理解把A1当作父亲，B1当作孩子，
public class exten {
    public static void main(String [] args){
        B1 b = new B1();
        b.setName("张三");
        System.out.println(b.getName());
    }
}

super() 操作/this()操作；没有无参构造时使用super()

package practice;
class D{
    public D(){
        System.out.println("A");
    }
}
class E extends D{
    public E(){
        super();   //若父类有无参构造，加不加都可以，子类对象实例化时会默认调用父类的无参构造
        System.out.println("B");
    }
}
public class ex1 {
    public static void main(String [] args){
        new E();
    }
}
-----------------------------------------------------------------------------------
package practice;
class D{
    public D(String title){
        System.out.println("A");
    }
}
class E extends D{
    public E(String title){
        super(title);  // this（）当前类中查找，extends（）父类查找，向父类查找
        System.out.println("B");
    }
}
public class ex1 {
    public static void main(String [] args){
        new E("d");
    }
}

多态

两种形式描述：
方法的多态性：方法的重载，同一个方法名称，会根据传入参数的类型及个数的不同执行不同的方法体；方法的覆写：同一个方法会根据子类的不同，实现不同的功能。
对象的多态性：指的是发生在继承关系类中，子类和父类的转换。
向上转型：父类 父类对象 = 子类实例； //自动完成
向下转型：子类 子类对象 = （子类）父类实例。 //强制完成
向上转型：

class A{
    public void print(){
        System.out.println("A");
    }
}
class B extends A {
    public void print(){
        System.out.println("B");
    }
}
------------------------------------------------------
//向上
public class Duo{
    public static void main(String [] args){
        A a = new B();
        a.print();
    }
}
-------------------------------------------------------
//向下
public class Duo{
    public static void main(String [] args){
        A a = new B();
        B b = (B)a;
        b.print();
    }
}

向上转型可以实现参数的统一

class A{
    public void print(){
        System.out.println("A");
    }
}
class B extends A {
    public void print(){
        System.out.println("B");
    }
}
class C extends A{
    public void print(){
        System.out.println("C");
    }
}
public class Duo{
    public static void main(String [] args){
      //子类均可以用父类接受
        A a1 = new B();
        A a2 = new C();
        a1.print();
        a2.print();
    }
}

向下转型：指的是父类要调用子类自己的特殊的方法。

class A{
    public void print(){
        System.out.println("A");
    }
}
class B extends A {
    public void print(){
        System.out.println("B");
    }
    public void fun(){
        System.out.println("fun");
    }
}
public class Duo{
    public static void main(String [] args){
        A a1 = new B();
        B b = (B)a1;
        b.fun();
    }
}

扩充方法

class A{
    public void print(){
        System.out.println("A");
    }
}
class B extends A {
    public void print(){
        System.out.println("B");
    }
    public void fun(){
        System.out.println("fun");
    }
}
public class Duo{
    public static void main(String [] args){
        funa(new B());
    }
    public static void funa(A a){
        B b = (B)a;
        b.fun();
    }
}

两个没有关系的类的对象强制向下转型时所带来的异常
Exception in thread "main" java.lang.ClassCastException: A cannot be cast to B
at Duo.main(Duo.java:14)

class A{
    public void print(){
        System.out.println("A");
    }
}
class B extends A {
    public void print(){
        System.out.println("B");
    }
}
public class Duo{
    public static void main(String [] args){
        A a = new A();   //A a = new B();
        B b = (B)a;
        b.print();
    }
}