java

封装

封装体现了java的面向对象的特点,用户不用知道程序是如何运行的,只用按照所给的格式输入参数,便可得到对应的结果.

一个完整的封装需要每个实例变量都用private来修饰并拥有相应的public getter和setter方法.

代码

 public class girl {
    private int age;
     public static int gender;
    public girl() {

    }

    public girl(int age) {
        int t;
        if (age >= 18 && age <= 50)
            this.age = age;
        else
            System.out.println("错误");
    }

    public void setAge(int x) {
        if (x >= 18 && x <= 50)
            age = x;
        else
            System.out.println("错误");
    }

    public int getAge() {
        if (age == 0)
            System.out.println("请先赋值");
        else
            return age;
        return 0;
    }

}

继承

类的继承通过extends关键字来实现,继承的类被称为子类,被继承的类被称为父类,子类拥有父类的全部成员变量和方法.

格式为

修饰符 class SubClass extends SuperClass{
    //类定义部分
}
//修饰符 public等
//SubClass 子类名
//SuperClass 父类名

每个子类只有一个直接父类但可以有无数个间接父类(父类的父类).

子类可以重写父类的方法,重写之后只有在子类方法中才可以调用被覆盖的父类方法(其他地方调用的是子类方法).

class BaseClass{
    public void test(){...}               //父类方法
}
class SubClass extends BaseClass{
    public void test(){                   //重写父类方法
    super.test();                         //调用父类方法
    }
}

重写时要注意重写的方法要遵循一下规则:

1.方法名和参数不变

2.返回值类型要和父类方法一样或是父类返值类型的子类型.

3.重写方法的访问控制修饰符不能比被重写方法更严格(如果父类方法是public,则重写方法不能定义为private).

public class women {
    private int age;
    public static int gender;

    public int getAge() {                           //父类方法
        if (age == 0)
            System.out.println("请先赋值");
        else
            return age;
        return 0;
    }

}
 class girl extends women {
    public int getAge() {                           //重写父类方法
        System.out.println(super.getAge());
        return 0;
    }

}

构造器

子类不会获得父类的构造器，但子类构造器里可以调用父类构造器.

子类通过super来调用父类的构造器,子类还可以通过this来调用本类的构造器,调用格式为

this(参数)    super(参数).

public class women {
    private int age;
    public static int gender;
    public women() {

    }

    public women(int age) {
        if (age >= 18 && age <= 50)
            this.age = age;
        else
            System.out.println("错误");
    }
}

class girl extends women {
    private int weight;
    public girl(int weight, int age) {
        super(age);
        this.weight = weight;
    }
}

多态

Java 引用变量有两个类型: 一个是编译时类型， 一个是运行时类型。 编译时类型由声明该变量时使 用的类型决定，运行时类型由实际赋给该变量的对象决定。 如果编译时类型和运行时类型不一致，就可 能出现所谓的多态 (Polymorphism).

多态的优势

当你需要对有着同一个父类的子类进行同一个操作的时候参数的设置就成了难题,你要对每一个子类都写一个方法供他们使用,但这样代码就会显得非常的臃肿,拥有着相同功能的代码出现了很多次,导致我们以后如果想修改功能我们就要对所有的方法进行修改,很麻烦,这时我们可以通过多态来解决.

多态的基本定义为 :   父类  变量名=new 子类();

子类其实是一种特殊的父类， 因此 Java 允许把一个子类对象直接赋给一个父类引用变量， 无须任何类型转换,或者被称为向上转型(upcasting) ，向上转型由系统自动完成。

public class person {
    private String name;
    private int age;

    public person() {
    }

    public person(String name, int age) {
        this.name = name;
        this.age = age;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


    public int getAge() {
        return age;
    }


    public void setAge(int age) {
        this.age = age;
    }
    public void show(){
        System.out.println(name+","+age);
    }
}

public class student extends person {
    @Override
    public void show() {
        System.out.println("学生的信息:"+getName()+","+getAge());
    }
}

public class administrator extends person{
    @Override
    public void show() {
        System.out.println("管理员的信息:"+getName()+","+getAge());
    }
}

public class teacher extends person {
    @Override
    public void show() {
        System.out.println("老师的信息:"+getName()+","+getAge());
    }
}

在以上这三个类中student,teacher和administrator都是person的子类,都分别重写了show方法(输出类中成员变量的值).

public class Main {
    public static void main(String[] args) {
        student a=new student();
        a.setAge(18);
        a.setName("张三");

        teacher b=new teacher();
        b.setAge(19);
        b.setName("李四");

        administrator c=new administrator();
        c.setAge(20);
        c.setName("王五");
        show(a);
        show(b);
        show(c);
    }
    public static void show(person p){
        p.show();
    }
}

运行结果

我们用父类来收这这三个子类的值就可以完成分别输出这三个类中成员变量的值.

多态中调用成员变量的特点

变量调用:编译看左边,运行看左边.

编译时会看父类中是否有这个变量,如果没有会报错.

运行时实际获取的是父类中成员变量的值

方法调用:编译看左边,运行看右边.

编译时会看父类中是否有这个方法,如果没有会报错.

运行时会运行子类的方法,实际上是父类中定义了该方法,子类覆盖了父类的该方法.

public class Main {
    public static void main(String[] args) {
        animal a=new dog();
        System.out.println(a.name);
        a.show();

    }
}
class animal{
     String name="动物";
     public void show(){
         System.out.println("animal");
     }

}
class dog extends animal{
    String name="狗";
    public void show(){
        System.out.println("dog");
    }
}