Java从入门到精通五(Java面向对象下,封装,继承,多态)

简介: 1:封装的概念在程序设计中,封装是一种将数据实现包装,隐藏起来的方法。数据是非常重要的,封装的出现,提高了数据的安全性。不能通过直接去访问数据,只能用程序中提供的可访问数据的接口。另外一点,就是通过封装,让我们更加方便的去访问自己所存储的数据,还有就是便于维护。

一:封装(Encapsulation)


1:封装的概念


在程序设计中,封装是一种将数据实现包装,隐藏起来的方法。数据是非常重要的,封装的出现,提高了数据的安全性。不能通过直接去访问数据,只能用程序中提供的可访问数据的接口。另外一点,就是通过封装,让我们更加方便的去访问自己所存储的数据,还有就是便于维护。


2:封装实现的过程


<1>修改类属性

常见的修改就是修改类中定义变量的访问权限。我们用private关键字修饰。被private修饰的属性只能被本类访问,其它的类是无法直接访问的,注意并不是不能访问。


对类属性的权限private化


package java_practice;
public class Student {
    private String name;
    private int age;
}


name,age都用private关键字修饰,使得name,age只能被本类访问。其它的外部类是不能访问的。这样相当于对外部类隐藏了属性,使得对属性的访问具有了一定的限制。


<2>提供接口


这里的接口是提供给外部类访问程序的接口。是两个方法。get(),set(),get()用于获取到值,set()用于对属性赋值。


具体如下示例


package java_practice;
public class Student {
    private String name;
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}


这样就基本实现了一个简单的封装。


3:外部类通过提供方法访问权限属性

上代码举例


package java_practice;
public class Student_Test {
    public static void main(String args[])
    {
        Student s = new Student();//创建Student类的对象
        s.setAge(18);
        s.setName("li");
        System.out.println(s.getName()+"今年"+s.getAge()+"岁");
    }
}


输出结果:



可以看到这样就可以正常访问了。


4既然接口都给了,封装还有什么意义?还不是可以访问?


可能你有这样的疑惑,特别是对于刚学的小白来说,不明白这样的意义。但是事实上并不是这样的,我们粉装的意义就是权限,是访问的限制规定,而不是禁止。当然你可以禁止,但是如果是禁止的话,也就没必要提供接口方法了。


怎么体现?我们还拿上段代码举例。我们可以在Student类中的set方法设置一些限定,以限制测试主类的属性的不恰当的修改。


来看代码


package java_practice;
public class Student {
    private String name;
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age<0||age>200)
        {
            System.out.println("赋值不合理");
        }
        System.exit(0);//甚至你可以直接退出
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}


然后测试类这样做了


package java_practice;
public class Student_Test {
    public static void main(String args[])
    {
        Student s = new Student();//创建Student类的对象
        s.setAge(201);
        s.setName("li");
        System.out.println(s.getName()+"今年"+s.getAge()+"岁");
    }
}

输出



你看,这样就对访问修改做了限制。当然你也可以这样。对get()方法里面进行操作。让用户传入参数,判断参数是否与你设定的一样,如果不一样,那就拒绝让外部类获取到值。这样就类似了一种口令。


二:继承(inheritance)


1:继承的概念


在程序设计中,面向对象也包含了继承这么一种设计理念。java中实现了类的继承,被继承的类叫做父类,继承的类叫子类。子类可以拥有父类的某些属性,注意是某些,不是全部。


继承的方式有多种,单继承,多继承,多重继承。java是不支持多继承的。也就是说,你一个子类不能继承多个父类,但是多个子类可以继承同一个父类。


2: 单继承


单继承很好理解,就是只有一个子类直接继承,子类没有被其它类继承。


//父类
package java_practice;
public class Student {
    private String name;
    private int age;
    public String place;
    static int number = 666;
    public int getAge() {
        return age;
    }
    public void describe()
    {
        System.out.println("学生:"+name_1);
    }
    public void setAge(int age) {
        if(age<0||age>200)
        {
            System.out.println("赋值不合理");
        }
        System.exit(0);//甚至你可以直接退出
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
//子类
package java_practice;
public class Studen_1 extends Student{
    public static void main(String args[])
    {
        System.out.println(number);//父类的number没有被private修饰
        //System.out.println(name);name没有被拥有,所以无法输出
        Student s = new Student();
        System.out.println(s.getName());//如果要访问,只能用提供的接口方法
    }
}


子类可以直接访问父类的共有变量这些属性,那么方法是怎么访问呢?对于一般的方法的访问方法


我们在分类写一个一般的共有方法,子类可以拥有这个属性。


子类调用父类的一般方法(当然该方法也被子类所拥有)


package java_practice;
public class Studen_1 extends Student{
    public static void main(String args[])
    {
        System.out.println(number);//父类的number没有被private修饰
        //System.out.println(name);
        Student s = new Student();
        System.out.println(s.getName());
        Studen_1 s1 = new Studen_1();
        s1.describe();//子类通过对象调用方法
    }
}

 

子类的继承父类的时候必须用做的那些事情。


必须调用父类的构造函数,如果父类有默认的构造函数,子类实例化会自动调用,如果父类没有声明默认的构造函数的话(无形参构造函数),子类构造函数必须通过super调用父类的构造函数。另外需要注意的是,子类构造函数必须通过super调用父类的构造函数。


在new()对象的时候,父类中的构造函数就会自动执行。


我在父类中写了一个无参构造方法


//父类
package java_practice;
public class Student {
    private String name;
    private int age;
    public String place;
    static int number = 666;
    String name_1 = "jgdabc";
    public Student(){
        System.out.println("Hello");
    }
    public void describe()
    {
        System.out.println("学生:"+name_1);
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age<0||age>200)
        {
            System.out.println("赋值不合理");
        }
        System.exit(0);//甚至你可以直接退出
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
//子类
package java_practice;
public class Studen_1 extends Student{
    public static void main(String args[])
    {
        System.out.println(number);//父类的number没有被private修饰
        //System.out.println(name);
        Student s = new Student();
        System.out.println(s.getName());
        Studen_1 s1 = new Studen_1();
        s1.describe();
    }
}


我们看执行结果



可以看到父类这个无参构造方法执行了两次。所以说,每一次new对象的时候这个无参构造方法会自动执行。


那么对于父类的有参构造方法呢?我们还是来看代码。我们在父类中写一个有参构造函数,将父类的无参覆盖掉。如果父类只有有参构造方法,那么子类必要用super关键字进行实现。我们需要这样做。看示例代码


//父类
package java_practice;
public class Student {
    private String name;
    private int age;
    public String place;
    static int number = 666;
    String name_1 = "jgdabc";
    /*public Student(){
        System.out.println("Hello");
    }*/
    public void describe()
    {
        System.out.println("学生:"+name_1);
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age<0||age>200)
        {
            System.out.println("赋值不合理");
        }
        System.exit(0);//甚至你可以直接退出
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
//子类
package java_practice;
public class Studen_1 extends Student{
    public Studen_1(int age) {
        super(age);
        //TODO Auto-generated constructor stub
    }
    public static void main(String args[])
    {
        System.out.println(number);//父类的number没有被private修饰
        //System.out.println(name);
        Studen_1 s = new Studen_1(18);
        s.describe();
    }
}



说明一下,父类的构造器是不能被子类继承的。子类默认继承父类的属性和方法,但不会继承父类的构造器,而是在子类被实例化时会默认调用父类的空构造器。子类在创建的时候会调用自己的空构造器,并在空构造器会隐式调用super(),即父类的空构造器。如果父类的构造器被重载,那么子类中的构造器也必须初始化父类的构造器,否则会报编译错误。


3: 多重继承


多重继承指的是什么


假如一个Student类作为父类,那么一个Student1类可以继承Student,Student2继承Student1。以此类推,但是你不能Student2既继承Student又继承Student1。


那么多重继承有什么特点呢?


我们还是代码举例说明


package java_practice;
public class Student {
    private String name;
    private int age;
    public String place;
    static int number = 666;
    String name_1 = "jgdabc";
    public Student(int age)
    {   this.age = age;
        System.out.println("我今年"+age+"岁");
    }
    // public Student(){
    //     System.out.println("Hello");
    // }
    public void describe()
    {
        System.out.println("学生:"+name_1);
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age<0||age>200)
        {
            System.out.println("赋值不合理");
        }
        System.exit(0);//甚至你可以直接退出
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
package java_practice;
public class Studen_1 extends Student{
    public Studen_1(int age) {
        super(age);
        //TODO Auto-generated constructor stub
    }
    public static void main(String args[])
    {
        System.out.println(number);//父类的number没有被private修饰
        //System.out.println(name);
        Studen_1 s = new Studen_1(18);
    }
}
package java_practice;
public class Student2 extends Studen_1 {
    public Student2(int age) {
        super(age);
        //TODO Auto-generated constructor stub
    }
    public static void main(String args[]){
        Student2 s2 = new Student2(19);
        s2.describe();
    }
}



可以看到多重继承的类依然可以访问其父类的父类的方法,也同样需要调用好有参构造器(直接父类的有参构造器)(父类的无参被有参覆盖掉。需要我们手动调用)同样也具有同样的非公有属性。


4:多个子类继承继承同一个父类

package java_practice;
public class Student2 extends Studen_1 {
    public Student2(int age) {
        super(age);
        //TODO Auto-generated constructor stub
    }
    public static void main(String args[]){
        Student2 s2 = new Student2(19);
        s2.describe();
    }
}
package java_practice;
public class Student3 extends Student {
    public Student3(int age) {
        super(age);
        //TODO Auto-generated constructor stub
    }
    public static void main()
    {
    }
}


三:多态(polymorphism)


1:多态的概念


多态是java面向对象的另外一个特征


简明的说,就是一个行为的不同表现形式。如何理解。比如说吃饭的的行为,你吃饭和别人吃饭的动作肯定是和别人多多少少都有不同表现的,那么这个就是多态。


2:实现多态的过程


1:实现继承(上述已经说明,不再赘述)

2:实现方法重写(一般方法)


注意:方法重写和方法重载是不一样的


首先说方法重载,简单就是一个类中多个同名方法,但是参数列表不一样(参数个数或者参数的类型)

而重写发生在继承关系,子类对父类的一般方法进行重写,参数列表以及方法名必须一致,然后内部的行为不一样。


举例一个方法重写的例子


同样给出父类和子类,我们对父类的describe()方法进行重写


//父类
package java_practice;
public class Student {
    private String name;
    private int age;
    public String place;
    static int number = 666;
    String name_1 = "jgdabc";
    public Student(int age)
    {   this.age = age;
        System.out.println("我今年"+age+"岁");
    }
    // public Student(){
    //     System.out.println("Hello");
    // }
    public void describe()
    {
        System.out.println("学生:"+name_1);
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age<0||age>200)
        {
            System.out.println("赋值不合理");
        }
        System.exit(0);//甚至你可以直接退出
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
//子类
package java_practice;
public class Studen_1 extends Student{
    public Studen_1(int age) {
        super(age);
        //TODO Auto-generated constructor stub
    }
    public void describe()
    {
        System.out.println("Long long ago!");
    }
    public static void main(String args[])
    {
        System.out.println(number);//父类的number没有被private修饰
        //System.out.println(name);
        Studen_1 s = new Studen_1(18);
        s.describe();
    }
}


实现多个子类重写父类相同的方法,便很生动的体现了多态。



可见子类重写父类的一般方法后,当子类再次调用这个方法就会调用到重写后的这个方法

3:对父类的引用指向子类对象(我们又可称为向上转型)

下面举一个例子。


package java_practice;
public class Student {
    private String name;
    private int age;
    public String place;
    static int number = 666;
    String name_1 = "jgdabc";
    public Student(int age)
    {   this.age = age;
        System.out.println("我今年"+age+"岁");
    }
    public Student() {
    }
    // public Student(){
    //     System.out.println("Hello");
    // }
    public void describe()
    {
        System.out.println("学生:"+name_1);
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age<0||age>200)
        {
            System.out.println("赋值不合理");
        }
        System.exit(0);//甚至你可以直接退出
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
package java_practice;
public class Studen_1 extends Student{
    public Studen_1(int age) {
        super(age);
        //TODO Auto-generated constructor stub
    }
    public Studen_1() {
    }
    public void describe()
    {
        System.out.println("Long long ago!");
    }
}
package java_practice;
public class Student2 extends Studen_1 {
    public Student2(int age) {
        super(age);
        //TODO Auto-generated constructor stub
    }
    public Student2() {
    }
    public void describe()
    {
        System.out.println("no body but you!");
    }
}
package java_practice;
public class Student3 extends Student {
    public Student3(int age) {
        super(age);
        //TODO Auto-generated constructor stub
    }
    public Student3() {
    }
    public void describe()
    {
        System.out.println("Believe you self!");
    }
}
package java_practice;
public class test {
       public static void main(String args[])
    {
        Student s = new Studen_1();//向上转型
        s.describe();
        Studen_1 s1 = new Studen_1();//进行向下转型
        s1.describe();
        show(new Student2());
        show(new Student3());
    }
    public static void show(Student a)
    {
        if(a instanceof Studen_1)
        {
            Studen_1 s1 = (Studen_1) a;
            s1.describe();
        }else if (a instanceof Student2)
        {
            Student2 s2 = (Student2)a;
            s2.describe();
        }else if (a instanceof Student3)
        {
            Student3 s3 = (Student3)a;
            s3.describe();
        }
    }
}


首先定义一个Student主类,Student_1继承Student,Student_2继承Student_1,Student_3继承Student2,然后我们再定义一个测试类,在测试类中进行具体对象的实现,并展示多态的效果。



我们也可以完全将父类写成一个抽象类,然后对抽象类中的属性或者方法进行具体的实现。


相关文章
|
8天前
|
Java 关系型数据库 数据库
面向对象设计原则在Java中的实现与案例分析
【10月更文挑战第25天】本文通过Java语言的具体实现和案例分析,详细介绍了面向对象设计的五大核心原则:单一职责原则、开闭原则、里氏替换原则、接口隔离原则和依赖倒置原则。这些原则帮助开发者构建更加灵活、可维护和可扩展的系统,不仅适用于Java,也适用于其他面向对象编程语言。
9 2
|
17天前
|
存储 Java 测试技术
Java零基础-多态详解
【10月更文挑战第10天】Java零基础教学篇,手把手实践教学!
15 4
|
22天前
|
Java 编译器 程序员
Java多态背后的秘密:动态绑定如何工作?
本文介绍了Java中多态的实现原理,通过动态绑定和虚拟方法表,使得父类引用可以调用子类的方法,增强了代码的灵活性和可维护性。文中通过具体示例详细解析了多态的工作机制。
29 4
|
26天前
|
存储 Java 测试技术
Java零基础-多态详解
【10月更文挑战第1天】Java零基础教学篇,手把手实践教学!
24 1
|
26天前
|
存储 Java 程序员
Java基础-面向对象
Java基础-面向对象
13 0
|
3月前
|
Java 程序员
Java中的继承和多态:理解面向对象编程的核心概念
【8月更文挑战第22天】在Java的世界中,继承和多态不仅仅是编程技巧,它们是构建可维护、可扩展软件架构的基石。通过本文,我们将深入探讨这两个概念,并揭示它们如何共同作用于面向对象编程(OOP)的实践之中。你将了解继承如何简化代码重用,以及多态如何为程序提供灵活性和扩展性。让我们启程,探索Java语言中这些强大特性的秘密。
|
28天前
|
Java
java继承和多态详解
java继承和多态详解
37 5
|
2月前
|
Java 编译器
Java——类与对象(继承和多态)
本文介绍了面向对象编程中的继承概念,包括如何避免重复代码、构造方法的调用规则、成员变量的访问以及权限修饰符的使用。文中详细解释了继承与组合的区别,并探讨了多态的概念,包括向上转型、向下转型和方法的重写。此外,还讨论了静态绑定和动态绑定的区别,以及多态带来的优势和弊端。
56 9
Java——类与对象(继承和多态)
|
3月前
|
Java
Java 新手入门:Java 封装、继承、多态详解
Java 新手入门:Java 封装、继承、多态详解
36 1
|
4月前
|
Java 数据安全/隐私保护
Java中的类继承与多态详解
Java中的类继承与多态详解