美文网首页程序员
Java的三大特性--封装、继承、多态

Java的三大特性--封装、继承、多态

作者: 我可能是个假开发 | 来源:发表于2018-12-15 17:25 被阅读5次

Java的三大特性

一、封装

public : 公共的。 public修饰的成员变量或者方法任何人都可以直接访问。
private ： 私有的。private修饰的成员变量或者方法只能在本类中进行直接访问。

1.封装的步骤

①使用private修饰需要被封装的属性。
②提供一个公共的方法设置或者获取该私有的成员属性。

命名规范：
set属性名();
get属性名();

注意：封装不一定要提供get和set方法，具体是要根据需求而定的。

2.规范

在现实开发中一般实体类的所有成员属性（成员变量）都要封装起来。
实体类：实体类就是用于描述一类 事物的就称作为实体类。

class Member{
    public  String name; //名字
    private String sex; //性别
    public  int salary; //薪水

    //定义一个公共的方法设置sex属性
    public void setSex(String s){
        if (s.equals("男")||s.equals("女")){ //注意： 如果比较两个字符串的内容是否一致，不要使用==比较， 使用equals方法。
            sex = s;
        }else{
            //默认是男
            sex = "男";
        }
    }
    //定义一个公共的方法获取sex属性
    public String getSex(){
        return sex;
    }
    //聊天
    public void talk(){
        System.out.println(name+"聊得非常开心");
    }
}

class Demo{

    public static void main(String[] args) 
    {
        Member m = new Member();
        m.name="小红";
        m.setSex("女");
        m.salary  = 5000;
        System.out.println("姓名："+ m.name+" 性别："+ m.getSex()+" 薪水："+ m.salary);
    }
}

实例：描述一个计算器类，计算器具备操作数1，操作数2 、操作符三个公共的属性
，还具备计算的功能行为。 不能直接对操作数1，操作数2，运算符这些属性进行直接 的赋值，要封装起来。

//计算器类
class Calculator{

    private int num1; //操作数1

    private int num2;  //操作数2
 
    private char option ; //运算符
    

    //提供公共的方法设置属性值....                  
    public void initCalculator(int n1 , int n2 , char o){
        num1 = n1;
        num2 = n2;
        if(o=='+'||o=='-'||o=='*'||o=='/'){
            option = o;
        }else{
            option = '+';   
        }
    
    }


    //计算的功能
    public void calculate(){
        switch(option){
            case '+':
                System.out.println("做加法运算,结果是："+(num1+num2));
                break;
            case '-':
                System.out.println("做减法运算,结果是："+(num1-num2));
                break;
            case '*':
                System.out.println("做乘法运算,结果是："+(num1*num2));
                break;
            case '/':
                System.out.println("做除法运算,结果是："+(num1/num2));
                break;
        }
    }
}

3.封装的好处

  • 提高数据的安全性。
  • 操作简单。
  • 隐藏了实现。

二、继承

在现实生活中事物与事物之间存在的两种关系：

  • 动物和猫 整体与部分的关系 has a
  • 程序员和人 继承的关系 is a

继承：使用关键字extends。

语法格式：

class 类名1 extends 类名2{
    
}

继承要注意的事项：

  1. 千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。
  2. 父类私有的成员不能被继承。
  3. 父类的构造函数不能被继承。
  4. 创建子类对象时默认会先调用父类无参的构造函数。
//人类 
class Person{
    
    String name;

    private int age;

    public  Person(String name){
        this.name = name;
    }

    public Person(){
        System.out.println("Person类的构造方法被调用了....");
    }

    public void eat(){
        System.out.println(name+"在吃饭...");
    }
}

//学生类
class Student extends Person {  // Student 就称作为Person类的子类， Person类就称作为Student的父类(超类、基类)

    int num; //学号

    public Student(){
        System.out.println("Student类的构造方法被调用了....");
    }

    public void study(){
        System.out.println(name+"good good study , day day up");
    }   
}

class Demo7 
{
    public static void main(String[] args) 
    {
        Student s = new Student();
        
        /*
        s.name = "小红";
        System.out.println("名字："+ s.name);
        s.eat();
        */
    }
}

创建子类对象时默认会先调用父类无参的构造函数的原因：
调用父类的构造方法是可以初始化从父类继承下去的属性的。

class Parent{
    
    int x = 10;
    String name;

    public Parent(String name){
        this.name = name;
        System.out.println("父类带参的构造方法");
    }

    public Parent(){
        System.out.println("父类无参的构造方法");
    }
}


class Child extends Parent{

    int x = 20;

    public Child(String name){
        super(name); //指定调用父类一个参数的构造函数。
    }

    public void print(){
        System.out.println("x1 = "+ x);
    }

}


class Demo
{
    public static void main(String[] args) 
    {
        Child c = new Child("大头儿子"); 
        System.out.println("name= "+c.name);

    }
}

super关键字

super关键字代表了父类空间的引用。

1.super关键字的作用：

  • 子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
  • 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。

2.super关键字调用父类构造方法要注意的事项：

  • 如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上面加上super()语句。
  • super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。
  • super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。

3.super关键字与this关键字的区别：

①代表的事物不一致。

  • super关键字代表的是父类空间的引用。
  • this关键字代表的是所属函数的调用者对象。

②使用前提不一致。

  • super关键字必须要有继承关系才能使用。
  • this关键字不需要存在继承关系也可使用。

③调用构造函数的区别：

  • super关键字是调用父类的构造函数。
  • this关键字是调用本类的构造函数。

demo：

class Parent{
        
    int x = 10;
    String name;

    public Parent(){
        System.out.println("父类无参的构造方法..");
    }

    public Parent(String name){
        this.name = name;
        System.out.println("父类带参的构造方法..");
    }

    public void eat(){
        System.out.println("爸爸做饭");
    }
}


class Child extends Parent{
    
    int x = 20; 
    int num;
    
    public Child(String name,int num){
        super(name); //指定调用了父类带参的构造方法...
        this(); // 调用本类无参构造方法..
        //super(); //指定调用了父类无参构造方法。。。
        System.out.println("子类带参的构造方法");
    }

    public Child(){
        System.out.println("子类无参的构造方法");
    }

    public void print(){
        System.out.println("x = " +super.x);
    }

    public void eat(){
        System.out.println("儿子吃饭");
    }
}

class Demo9 {

    public static void main(String[] args) 
    {
        Child c = new Child("小红");
    }
}

方法的重写

方法重写的前提：必须要存在继承的关系。

方法的重写：子父类出了同名的函数，这个我们就称作为方法的重写。

适用场景：父类的功能无法满足子类的需求时。

注意事项：
1.方法重写时，方法名与形参列表必须一致。
2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
3.方法重写时，子类的返回值类型必须要小于或者 等于父类的返回值类型。
4.方法重写时，子类抛出的异常类型要小于或者等于父类抛出的异常类型。

class Animal{  //大的数据类型 
}

class Fish extends Animal{  //Fish 小的数据类型。
}

class Parent{

    String name;

    public Parent(String name){
        this.name = name;
    }

    public Animal eat() throws RuntimeException {
        System.out.println(name+"做饭");
        return new Animal();
    }
}


class Child extends Parent{

    String num;
    
    public Child(String name){
        super(name);//指定调用父类带参的构造方法
    }

    //重写父类的eat方法
    public Animal eat() throws Exception{
        System.out.println("喝汤");
        System.out.println("吃肉");
        System.out.println("吃青菜");
        return new Animal();
    }
}

class Demo{

    public static void main(String[] args) 
    {
        Child c = new Child("大头儿子");
        c.eat();
    }
}

方法的重载

方法的重载：在一个类中 存在两个或者两个 以上的同名函数,称作为方法重载。

方法重载的要求：

  1. 函数名要一致。
  2. 形参列表不一致（形参的个数或形参 的类型不一致）
  3. 与返回值类型无关。

instanceof关键字

instanceof关键字的使用前提：判断的对象与指定的类别必须要存在继承或者实现的关系。

instanceof关键字的使用格式：

    对象  instanceof 类别

instanceof关键字的作用：判断一个对象是否属于指定的类别。
一般我们做强制类型转换之前都会使用该关键字先判断一把，然后再进行转换的。

class Animal{

    String name;
    String color;

    public Animal(String name, String color){
        this.name = name;
        this.color = color;
    }
}


//狗是属于动物中一种
class Dog extends Animal {

    public Dog(String name,String color){
        super(name,color); //指定调用父类两个 参数的构造函数。
    }

    public void bite(){
        System.out.println(name+"咬人!!");
    }
}

//猫也是属于动物中一种
class Cat extends  Animal{
    
    public Cat(String name,String color){
        super(name,color);
    }
    
    public void eat(){
        System.out.println(name+"吃鱼..");
    }

}

class Demo{

    public static void main(String[] args) 
    {
        Dog d = new Dog("哈士奇","白色");
        System.out.println("狗是狗类吗？"+ (d instanceof Dog));
        System.out.println("狗是动物类吗？"+ (d instanceof Animal));   
        //System.out.println("狗是猫类吗？"+ (d instanceof Cat));     // false true
        
        Animal a = new Animal("小红","黄色"); //小红是人
        System.out.println("动物都是狗吗？"+ (a instanceof Dog));
    }
}

final关键字

用法：

  1. final关键字修饰一个基本类型的变量时，该变量不能重新赋值，第一次的值为最终的。
  2. fianl关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。
  3. final关键字修饰一个函数的时候，该函数不能被重写。
  4. final关键字修饰一个类的时候，该类不能被继承。
//圆形
class Circle{

    double r; //半径
    public static final double pi = 3.14; //固定不变的

    public Circle(double r){
        this.r = r;
    }

    //计算面积
    public final void getArea(){
        System.out.println("圆形的面积是："+r*r*pi);
    }
}

class Demo extends Circle
{
    
    public Demo(double r){
        super(r);
    }

    public static void main(String[] args) 
    {
        /*
        final Circle c = new Circle(4.0);
        test(c);
        */  
        Demo c = new Demo(4.0);
        c.getArea();
    }
    
    public static void test(Circle c){
        c = new Circle(5.0);  //c变量又重新指向了新的对象。
        c.getArea();
    }

}

三、多态

1.概念

多态：一个对象具备多种形态。
①父类的引用类型变量指向了子类的对象
②接口的引用类型变量指向了接口实现类的对象

多态的前提：必须存在继承或者实现关系。

动物 a  = new 狗();

2.多态要注意的细节：

  1. 多态情况下，子父类存在同名的成员变量时，访问的是父类的成员变量。
  2. 多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数。
  3. 多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数。
  4. 多态情况下，不能访问子类特有的成员。

总结：多态情况下，子父类存在同名的成员时，访问的都是父类的成员，除了在同名非静态函数时才是访问子类的。

注意：java编译器在编译的时候，会检查引用类型变量所属的类是否具备指定的成员，如果不具备马上编译报错。（编译看左边）

//动物类
abstract class Animal{

    String name;
    String  color = "动物色";

    public Animal(String name){
        this.name = name;
    }

    public abstract void run();

    public static void eat(){
        System.out.println("动物在吃..");
    }

}

//老鼠
class  Mouse extends Animal{

    String color = "黑色";

    public Mouse(String name){
        super(name);
    }
    
    public  void run(){
        System.out.println(name+"在大街上窜");
    }

    public static void eat(){
        System.out.println("老鼠在偷吃..");
    }

    //老鼠特有方法---打洞
    public void dig(){
        System.out.println("老鼠在打洞..");
    }
}

class Fish extends Animal {

    public Fish(String name){
        super(name);
    }
    
    public  void run(){
        System.out.println(name+"慢慢的游");
    }
}

class Demo
{
    public static void main(String[] args) 
    {
        /*
        Mouse m = new Mouse("老鼠");
        System.out.println(m.color);
        
        //多态： 父类的引用类型变量指向子类的对象
        */
        Animal a = new Mouse("老鼠");
        a.dig();
        //a.eat();
    }   
}

4.多态的应用：

  1. 多态用于形参类型的时候，可以接收更多类型的数据。
  2. 多态用于返回值类型的时候，可以返回更多类型的数据。

多态的好处： 提高了代码的拓展性。

定义一个函数可以接收任意类型的图形对象，并且打印图形面积与周长。

//图形类
abstract class MyShape{

    public abstract void getArea();
    public abstract void getLength();   
}



class Circle extends MyShape{

    public static final double PI = 3.14;
    double r;

    public Circle(double r){
        this.r =r ; 
    }

    public  void getArea(){
        System.out.println("圆形的面积："+ PI*r*r);
    }

    public  void getLength(){
        System.out.println("圆形的周长："+ 2*PI*r);
    }
}


class Rect  extends MyShape{

    int width;
    int height;

    public Rect(int width , int height){
        this.width = width;
        this.height = height;
    }

    public  void getArea(){
        System.out.println("矩形的面积："+ width*height);
    }

    public  void getLength(){
        System.out.println("矩形的周长："+ 2*(width+height));
    }
}



class Demo{

    public static void main(String[] args) 
    {
        /*
        //System.out.println("Hello World!");
        Circle c = new Circle(4.0);
        print(c);

        Rect r = new Rect(3,4);
        print(r);
        */
        MyShape m = getShape(0); //调用了使用多态的方法，定义的变量类型要与返回值类型一致。
        m.getArea();
        m.getLength();
    }

    //需求1： 定义一个函数可以接收任意类型的图形对象，并且打印图形面积与周长。
    public static void print(MyShape s){ // MyShpe s = new Circle(4.0);
        s.getArea();
        s.getLength();
    }
    // 需求2： 定义一个函数可以返回任意类型的图形对象。
    public static MyShape  getShape(int i){
        if (i==0){
            return new Circle(4.0);
        }else{
            return new Rect(3,4);
        }
    }
}

5.数据类型转换

目前多态情况下不能访问子类特有的成员。
如果需要访问子类特有的成员，那么需要进行类型强制转换.

①基本数据类型的转换

  • 自动类型转换：小数据类型--->大数据类型
  • 强制类型转换：大数据类型--->小数据类型 小数据类型 变量名 = （小数据类型）大数据类型;

②引用数据类型的转换

  • 自动类型转换：小数据类型--->大数据类型
  • 强制类型转换：大数据类型--->小数据类型
//动物类
abstract class Animal{

    String name;

    public Animal(String name){
        this.name = name;
    }

    public abstract void run();
}

//老鼠
class  Mouse extends Animal{

    public Mouse(String name){
        super(name);
    }
    
    public  void run(){
        System.out.println(name+"在大街上窜!");
    }

    //老鼠特有方法---打洞
    public void dig(){
        System.out.println("老鼠在打洞..");
    }
}

//鱼
class Fish extends Animal{

    public Fish(String name){
        super(name);
    }

    public  void run(){
        System.out.println(name+"在水里慢慢的游!");
    }

    //吹泡泡
    public void bubble(){
        System.out.println(name+"吹泡泡...!");
    }

}

class Demo2 
{
    public static void main(String[] args) 
    {
        /*
        Animal a = new Mouse("老鼠");  //多态
        //调用子类特有的方法
        Mouse m  = (Mouse)a;  //强制类型转换
        m.dig();
        */

        Mouse m = new Mouse("米老鼠");
        Fish f = new Fish("草鱼");

        print(f);

    }

    //需求： 定义一个函数可以接收任意类型的动物对象，在函数内部要调用到动物特有的方法。
    public static void print(Animal a){ // Animal a   = new Mouse("米老鼠");
        if(a instanceof Fish){
            Fish f = (Fish)a;
            f.bubble();
        }else if(a instanceof Mouse){
            Mouse m = (Mouse)a;
            m.dig();
        }
    }

}

多态： 父类的引用类型变量指向了子类的对象或者是接口类型的引用类型变量指向了接口实现类的对象。

实现关系下的多态：

接口  变量  = new  接口实现类的对象。

Demo:

interface Dao{  //接口的方法全部都是非静态的方法。
    public void add();
    public void delete();
}

//接口的实现类
class UserDao implements Dao{
    
    public void add(){
        System.out.println("添加员工成功！！");
    }

    public void delete(){
        System.out.println("删除员工成功！！");
    }

}

class Demo
{
    public static void main(String[] args) 
    {
        //实现关系下的多态
        Dao d = new UserDao(); //接口的引用类型变量指向了接口实现类的对象。
        d.add();
    }
}

相关文章

  • Java的基本特性

    关系 Java的四个基本特性分别是抽象，封装，继承，多态。概括起来可以这么理解，抽象、封装、继承是多态的基础，多态...

  • 2020-07-08 腾讯客户端开发面试

    项目经历 java 三大特性？java 可以多继承吗？如何实现多继承？多态有哪些类型？封装，继承，多态；不可以；接...

  • day09-Java面向对象三（多态/抽象类/接口）

    9.0 Java面向对象三大特性 封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的 多态概念：指...

  • 招银网络面试题、考点、知识点总结（Java岗）

    java基础 全是基础不用多说肯定考的多，尤其是招银 OOP特性/java语言特性：封装、继承、多态 多态具体的表...

  • 招银网络面试题、考点、知识点总结（Java岗）

    java基础 全是基础不用多说肯定考的多，尤其是招银 OOP特性/java语言特性：封装、继承、多态 多态具体的表...

  • 面向对象三大特性

    三大特性：继承 封装 多态 继承 Java中的继承只能单继承，但是可以通过内部类继承其他类来实现多继承。 封装 封...

  • iOS开发之一OC语言的特性

    三大特性：封装、继承、多态 一、封装（成员变量的封装） 二、继承 三、多态（多种形态）

  • JAVA

    Java语言的特性 Java的三大特性：封装、继承、多态 封装：隐藏对象的属性和实现细节，仅对外提供公共的访问方式...

  • java多态总结

    Java多态 1、多态的总结 面向对象编程有三大特性：封装、继承、多态。 封装隐藏了类的内部实现机制，可以在不影响...

  • 多态

    1.理解java的三大特性之多态 面向对象编程有三大特性：封装、继承、多态。 封装隐藏了类的内部实现机制，可以在不...

网友评论

    本文标题：Java的三大特性--封装、继承、多态

    本文链接：https://www.haomeiwen.com/subject/abvahqtx.html

    延伸阅读

    深度阅读

    • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

    栏目导航

    热点阅读

    程序员

    关于我们|服务条款|联系我们|Java的三大特性--封装、继承、多态|投稿指南|网站地图|RSS订阅|排版工具|手机版

    提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

    Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

    备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

    本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

    所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！