面向对象的三大特性

R.PeiLi

于 2022-06-09 17:49:18 发布

阅读量82

点赞数

分类专栏： java学习笔记文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_51141264/article/details/125196675

版权

java学习笔记专栏收录该内容

22 篇文章 0 订阅

订阅专栏

封装

该露的露，该藏的藏

我们程序设计要求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：尽暴露少量的方法给外部使用。

封装（数据的隐藏）

禁止直接访问一个对象中数据的实际表示，应该通过操作接口来访问，称为信息隐藏
属性私有：get/set
属性使用private后无法直接调用，换成public后则可以直接调用
在这里插入图片描述

封装的作用

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统的可维护性增加

//类  private:私有
public class Student {
     //属性私有
     private String name;      //名字
     private  int id ;         //学号
     private char sex;        //性别
     private int age;   //年龄 年龄设置在0-100岁之间

     //提供一些可以操作这个属性的方法
     //提供一些public 的get、set方法

     //get获得这个数据
     public String getName() {
          return name;
     }
     //set 给这个数据设置值
     public void setName(String name) {
          this.name = name;
     }

     public int getId() {
          return id;
     }

     public void setId(int id) {
          this.id = id;
     }

     public char getSex() {
          return sex;
     }

     public void setSex(char sex) {
          this.sex = sex;
     }

     public int getAge() {
          return age;
     }

     public void setAge(int age) {
          if (age>0 && age<100) {
               this.age = age;
          }else {
               System.out.println("年龄不合法");
          }
     }
}


/** 封装的作用
 1.提高程序的安全性，保护数据
 2.隐藏代码的实现细节
 3.统一接口
 4.系统的可维护性增加
 */


//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("李佩蓉");
        System.out.println(s1.getName());//李佩蓉
        s1.setAge(110);
        System.out.println(s1.getAge());//年龄不合法 0

    }
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模（类与类之间）
extends的意思是“扩展”，子类是父类的扩展
**java中类只有单继承，没有多继承！**一个儿子只能有一个爸爸，一个爸爸可以有多个儿子。

继承是类和类之间的一种关系
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类使用关键词extends来表示。
子类可以继承父类的所有方法
子类无法继承父类私有的东西

在这里插入图片描述
在java中，所有的类都都默认直接或间接继承Object中

Super - this

super注意点：

1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法

this:

代表的对象不同：

this:本身调用者这个对象
super:代表父类对象的应用
前提：
this：没有继承也可以使用
super:只能在继承的条件下才能使用
构造方法：
this():本类的构造
super():父类的构造

父类：

//人 父类（基类）
public class Person {
    public Person() {
        System.out.println("Person无参构造执行了");
    }

    protected String name = "guaigaui";

    public void print(){
        System.out.println("Person");
    }
}

子类：

//学生类 子类（派生类）继承父类Person(基类)
//子类继承父类，就会拥有父类的全部方法！
public class Student extends Person{
    public Student() {
        //隐藏代码：调用了弗雷德无参构造
       // super();//调用了父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参构造执行了");
    }

    private String name = "lipeirong";

    public void print(){
        System.out.println("Student");
    }

    public void test1(){
       print();  //Student调用当前的类
        this.print();//Student
        super.print();//Person
    }

    public void test(String name){
        System.out.println(name);//李佩蓉
        System.out.println(this.name);//lipeirong
        System.out.println(super.name);//guaigaui
    }

}

测试类：


//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
       // student.test("李佩蓉");
      //  student.test1();
    }

总览：
在这里插入图片描述

方法重写

需要在非静态的方法下才能实现重写
重写：需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大 public>protected>default>private
4.抛出的异常：范围可以被缩小，但不能被扩大

重写，子类的方法和父类必须要一致，方法体不同!

为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足！
alt+insert:override

方法不能被重写：
1.static 方法，属于类,他不属于实例
2.final 常量;
3.private 私有方法
子类：

//继承关系
public class A extends B{

    //Override 重写
    @Override //注解：有功能的注释
    public void test() {
        System.out.println("A-->test()");
    }
}

父类：

//重写都是方法的重写，和属性无关
public class B {
    public  void test(){
        System.out.println("B-->test()");
    }
}

测试类：

//静态方法和非静态的方法区别很大
//静态方法调用之和左边定义的数有关

//一个项目应该只存一个main方法
public class Application {
    public static void main(String[] args) {
        //方法事物调用只和左边，定义的数据有关
        A a = new A();
        a.test(); //A-->test()

        //父类的引用指向了子类
        B b = new A(); //子类重写了父类的方法
        b.test();//A-->test()


    }
}

总览：
在这里插入图片描述

多态（没有继承关系就没有多态）

即同一个方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多
多态存在的条件：
有继承关系
子类重写父类的方法
父类引用指向子类
注意：多态是方法的多态，属性没有多态

子类：

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat()
    {
        System.out.println("eat");
    }
}

父类：

public class Person {

    public void run(){
        System.out.println("run");
    }

}

 多态注意事项：
 1.多态是方法的多态，属性没有多态
 2.父类和子类 有关系   类型转化异常ClassCastException!
 3.存在条件：继承关系，方法需要重写，父类的引用指向子类对象!  father f1 = new son;

 方法不能被重写：
 1.static  方法，属于类,他不属于实例
 2.final  常量;
 3.private 私有方法

实现类：

public class Application {
    public static void main(String[] args) {

        //一个对象的实际类型是确定的
        //new Student();
       //new Person();

        //可以指向的引用类型就不确定了:父类的引用指向子类
        //Student  能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，和右边的类型关系不大！
        s2.run(); //子类重写了父类的方法，执行子类的方法
        s1.run();
    }
}

总览：
在这里插入图片描述

instanceof和类型转换

instanceof判断一个对象是什么类型

子类1：

public class Person {

    public void run(){
        System.out.println("run");
    }

}

 多态注意事项：
 1.多态是方法的多态，属性没有多态
 2.父类和子类有关系   类型转化异常ClassCastException!
 3.存在条件：继承关系，方法需要重写，父类的引用指向子类对象!  father f1 = new son;

 方法不能被重写：
 1.static  方法，属于类,他不属于实例
 2.final  常量;
 3.private 私有方法

子类2：

public class Teacher extends Person{
}

父类：

public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}

测试类：

public class Application {
    public static void main(String[] args) {
        //类型之间的转换
       // 高                     低
        Person student = new Student();

        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法
        /*  Student student1 = (Student) student;
        student1.go();*/
       // ((Student) student).go();
        Person person = student;
    }
}

      // System.out.println(x instanceof y);//能不能编译通过，看x与y之间是否有关系
  // Object >String
  //  Object > Person >Student
   // Object >Person >Teacher
   // Object object = new Student();
        System.out.println(object instanceof Student); //true
                System.out.println(object instanceof Person); //true
                System.out.println(object instanceof Object); //true
                System.out.println(object instanceof Teacher); //false
                System.out.println(object instanceof String);//false
                System.out.println("==========================================");
                Person person =new Student();
                System.out.println(person instanceof Student); //true
                System.out.println(person instanceof Person); //true
                System.out.println(person instanceof Object); //true
                System.out.println(person instanceof Teacher); //false
                // System.out.println(person instanceof String);//编译报错！
                System.out.println("==========================================");
                Student student =new Student();
                System.out.println(student instanceof Student); //true
                System.out.println(student instanceof Person); //true
                System.out.println(student instanceof Object); //true
// System.out.println(student instanceof Teacher); //编译报错！
// System.out.println(person instanceof String);//编译报错！

1.父类引用指向子类对象
2.把子类转换为父类向上转型不用强制转换
3.把父类转换为子类向下转换需要强制转换可能会丢失方法
4.方便方法的调用，减少重复代码，简洁

重载和重写的详细区别
 继承关系中除了父类private方法，其他方法能被继承吗？

R.PeiLi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象的三大特性

我们程序设计要求“高内聚，低耦合”。高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：尽暴露少量的方法给外部使用。禁止直接访问一个对象中数据的实际表示，应该通过操作接口来访问，称为信息隐藏属性私有：get/set属性使用private后无法直接调用，换成public后则可以直接调用继承继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模（类与类之间）extends的意思是“扩展”，子类是父类的扩展**java中类只有单继承，没有多继承！**一个儿子只能有一个爸爸，一个爸
复制链接

扫一扫