java的面向对象，继承，封装，多态

目录

一、什么是面向过程

二、什么是面向对象

三、类

四、面向对象的三大基本特征是什么

1、封装

2、继承

3、多态

---

一、什么是面向过程

面向过程是一种以过程为中心的编程思想，其原理就是将问题分解成一个一个详细的步骤，然后通过函数实现每一个步骤，并依次调用
面向过程我们所关心的是解决一个问题的步骤，举个例子，汽车发动、汽车熄火，这是两个不同的事件，对于面向过程而言，我们关心的是事件本身，因此我们会使用两个函数完成以上两个动作，然后依次调用即可

二、什么是面向对象

面向对象则是一种以对象为中心的编程思想，就是通过分析问题，分解出一个一个的对象，然后通过不同对象之间的调用来组合解决问题。建立对象的目的不是为了完成某个步骤，而是为了描述某个事物在解决整个问题的过程中的行为
如上面的例子，汽车发动、汽车熄火，对于面向对象而言，我们则关心的是汽车这类对象，两个事件只是这类对象所具备的行为

三、类

类是对一组有相同数据和相同操作的对象的定义，是对象的模板，其包含的方法和数据描述一组对象的共同行为和属性。类是在对象之上的抽象，对象则是类的具体化，是类的实例。类可有其子类，也可有其他类，形成类层次结构。

 

四、面向对象的三大基本特征是什么

1、封装

封装就是将一个类的某些信息隐藏在类的内部，不允许外界直接访问，而是提供某些方法实现对隐藏信息的访问和操作
封装的好处就是增强了数据安全性以及隐藏了类的实现细节，使用者无需了解具体实现细节，只需通过特定的接口进行访问，这样也方便类自身的实现和修改

封装的使用

**
 * 封装 :把属性私有化，实现了对外界的隐藏，然后通过共有的getter和setter方法对属性进行获取和赋值，保证了操作的安全性。
 * 一般属性私有化(private)，方法公有化(public)，除非方法只是用来内部调用，可以private修饰
 * 1.对属性使用private私有化进行修饰，实现了对外界的隐藏，外界不能够直接操作类的属性。
 * 2.定义针对属性的getter和setter方法，完成对属性的获放和设置值，在发放中可以完成完会验证。
 *
 * 注意:
 * 属性私有化后也可以通过有参数的构造方法进行赋值，且在有参构造方法中进行安全验证。
 */
public class Student {
 
    //成员变量 （属性）-----变量----储存数据的
    private String name;
    private String sex;
    private  int age;
    private  double height;
 
    /**
     * 构造方法：用来初始化对象（构造方法是用来创建对象的）
     * 语法：  访问修饰符 类名（参数列表..）{}
     */
    //无参构造方法
    public Student(){
        System.out.println("无参的构造方法被调用！");
    }
    //有参构造方法:可以实现对类的属性进行赋值
    public Student(String name, String sex, int age, double height) {
        System.out.println("有参的构造方法被调用！");
        this.name = name;
        this.sex = sex;
        if(age>=0&&age<=100){
            this.age = age;
        }
        if (height>0){
            this.height = height;
        }
    }
 
    //getter setter
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String getSex() {
        return sex;
    }
 
    public void setSex(String sex) {
        this.sex = sex;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public double getHeight() {
        return height;
    }
 
    public void setHeight(double height) {
        this.height = height;
    }
 
    //toString：打印类的对象是打印的内存地址，重写了该方法，打印时就显示的是类的属性值列表
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                ", height=" + height +
                '}';
    }
 
    //成员方法（行为）----方法----完成---完成一些功能的---面向对象的体现
    public void introduce(){
        System.out.println("我是"+name+",性别"+sex+",今年"+age+"岁,身高:"+height);
    }
}
 
public class Test {
    public static void main(String[] args){
        //调用构造方法，实例化类的对象
        Student stu = new Student();
        stu.setName("张三");
        stu.setSex("男");
        stu.setAge(18);
        stu.setHeight(185.3);
        stu.introduce();
        System.out.println(stu);
 
        System.out.println("----------------------");
        Student stu1 = new Student("李四","男",29,217);
        stu1.introduce();
    }
}

2、继承

继承是类与类之间的一种关系，即子类继承父类的特征和行为，使得子类具有和父类相同的属性和行为
继承的好处在于子类继承了父类的属性和方法从而实现了代码的复用

class Dog{
 
 public String name="小白";
 
  public void say(){
 
     System.out.println("汪汪汪");
 
   }
 
}
 
//哈奇士
 
class haqishi extends Dog {
 
    public void test(){
 
       System.out.println(name);
 
        say();
 
    }
 
调用haqishi的test()方法，测试如下：
 
小白
 
汪汪汪
 
测试结果：子类haqishi继承了父类的成员变量和成员方法
 
父类继承过来的方法，子类可以进行改造，重新实现功能（方法的重写），调用的时候执行的是子类新实现的方法。
 
重写父类方法
 
子类haqishi重写父类Dog的say方法
 
 
class Dog{
 
   public String name="小白";
 
    public void say(){
 
      System.out.println("汪汪汪");
 
    }
 
}
 
//哈奇士
 
class haqishi extends Dog {
 
    public void say() {
 
       //super.say();    继承父类原有方法
 
       System.out.println("哈哈哈");    }
 
}
 
调用子类say方法，测试如下：
 
哈哈哈
 
重载父类方法
 
重载方法必须满足以下条件：
 
1、方法名相同
 
2、方法的参数类型、个数、顺序至少有一项不同
 
3、方法的返回类型可以不同
 
4、方法的修饰符可以不相同
 
 
class Dog{
 
    public String name="小白";
 
    public void say(){
 
        System.out.println("汪汪汪");
 
    }
 
}
 
//哈奇士
 
class haqishi extends Dog {
 
   //重载 改变参数
 
    public void say(String name) {
 
       System.out.println(name+"汪汪汪");
 
    }
 
//重载 改变参数+返回值
 
    public int say(int age) {
 
        System.out.println("汪汪汪"+age);
 
        return age;
 
    }
 
 
分别调用:/
 
haqishi h = new haqishi();
 
h.say();
 
h.say(“哈奇士”);
 
h.say(6);

3、多态

多态是指一个类对象的相同方法在不同情形下有不同的表现形式
多态使得具有不同内部结构的对象可以共享相同的外部接口

接口语法的实现

先声明USB接口：其中规定了要实现USB接口就必须实现接口规定实现的read( )和write( )这两个方法

interface USB {
    void read();
 
    void write();
}

然后在写一个两个类，这两个类都去实现USB接口（实现其中的方法）

class Jinshidun implements USB {
    @Override
    public void read() {
        System.out.println("金士顿正在通过USB功能读取数据");
    }
    @Override
    public void write() {
        System.out.println("金士顿正在通过USB功能写入数据");
    }
}

class Shandi implements USB {
    @Override
    public void read() {
        System.out.println("闪迪正在通过USB功能读取数据");
    }
    @Override
    public void write() {
        System.out.println("闪迪正在通过USB功能写入数据");
    }
}
 

那么，现在两个类都实现了USB功能，也就是说两个类都能够调用USB接口中规定的方法，并且他们实现的方式都不一样