Java面向对象-封装&继承&多态

一、类的定义:

/*
class 类名称
{
    属性;
    方法;
}
*/

class Person
{
    String name;
    int age;
    void talk()
    {
        System.out.println("我是:" + name + ",今年:" + age + "岁！" );
    }
}

二、封装：

      类中可以对属性和方法设置权限:

	本类	子类	同包类	其他类
public	可以	可以	可以	可以
protected	可以	可以	可以	不可以
默认	可以	同包子类可以	可以	不可以
private	可以	不可以	不可以	不可以

 

 

 

 

 

 

/*
    将类的属性 私有化， 通过设置共有方法 来修改和 获取类的属性，达到安全。
*/
class Person
{
    private String name; 
    public void setName(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return this.name;
    }
}

三、继承:

      类的继承主要目的是代码复用，java中只支持单继承

/*
    学生类继承人类
*/
class Person
{
    public String name;
    public int age;
}

class Student extends Person
{
    public String school;
}

    构造方法: 构造方法在实例化对象的时候被调用，主要作用是对象属性的初始化，开辟存储空间，构造函数可以自定义

/*
    构造方法：
        1.系统有默认的构造方法
        2.实例化子类对象时,先调用父类的构造方法，在调用子类构造方法(自定义子类构造方法时候，必须将调用父类构造方法写在第一句)
*/
class Person
{
    public String name;
    public int age;
    public Person(String name,int age) // 自定义构造方法
    {
        this.name = name;
        this.age = ege;
        System.out.println("Person 构造方法被调用!");
    }
}
class Student extends Person
{
    public String school;
    public Student(String name,int age,String school) // 自定义子类构造方法
    {
        super(name,age);// 调用父类构造方法
        this.school = school;
        System.out.println("Student 构造方法被调用!");
    }
}

四、多态

      多态在程序中表现为 子类在继承父类的同时 将根据自身需要重写父类的相关方法，从而表现为子类各种特征

/*
    本例中 B 和 C 都继承 类 A，都重写 类 A中 fun1 方法
*/
// 父类 A
class A
{
    public void fun1()
    {
        System.out.println("父类A fun1...");
    }
    public void fun2()
    {
        this.fun1();
    }
}
// 子类B
class B extends A
{
    public void fun1() // 重写父类 fun1方法
    {
        System.out.println("子类B fun1...");
    }
    public void fun3() // 子类 fun3 方法
    {
        System.out.println("子类B fun3...");
    }
}
// 子类C
class C extends A
{
    public void fun1() // 重写父类 fun1方法
    {
        System.out.println("子类C fun1...");
    }
    public void fun4() // 子类 fun4 方法
    {
        System.out.println("子类C fun4...");
    }
}
class Test
{
    public static void main(String [] args)
    {
        fun(new B());
        fun(new C());
    }
    public static void fun(A a) // 利用 多态性 处理 A类 的派生类
    {
        a.fun2() // 这里将调用 a 子类重写后的方法
        if( a instanceof B)
        {
            B b = (B)a; // 向下转型
            b.fun3();
        }
        if(a instanceof C)
        {
            C c = (C)a; // 向下转型
            c.fun4();
        }
    }
}