面向对象编程

2021/4/10 18:12:02

编程Tag： 方法 name 子类 父类 public void 面向对象编程

本文主要是介绍面向对象编程，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1.初识面向对象

面向过程和面向对象比较

面向过程的思想

​ 步骤清晰简单，第一步做什么，第二部做什么，面向过程适合处理一些较为简单的问题

面向对象的思想

​ 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

总结：

​ 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

​ 面向对象编程（Object-Orient Programing, OPP）

​ 面向对象的本质：以类的方式组织代码，以对象的方式组织（封装）数据。

抽象

​ 怎么样理解抽象，举个例子，一个学生管理系统，里面有学生的姓名，学号，班级，身高，体重等等。我们抽取其中的比如说姓名和学号组成一个类。这是一个对抽象形象的解释。

三大特性

封装：把代码里数据封装起来。

继承：子类可以继承父类的东西。

多态：对同一个方法，不同的事物通过这个方法所得出的结果是不一样的。

​ 从认识论的角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

​ 从代码运行的角度考虑是先有类后有对象，类是对象的模板。

1.类与对象

  • 类是一种抽象的数据类型，它是对某一类事物整体的描述、定义，但是并不能代表某一具体的事物。例如：植物，动物.....
  • 对象是抽象概念的具体实例，例如：仙人掌就是植物的一个具体的实例；狗就是动物的一个实例...

2.方法
定义、调用：！
3.对象的引用
引用类型： 基本类型（8）
对象是通过引用来操作的：栈-->堆

4.属性：字段Field 成员变量
默认初始化：
数字： 0 0.0
char： u0000
boolean： false
引用： null

​ 修饰符 属性类型 属性名 = 属性值！

5对象的创建与使用

  • 必须使用new 关键字创造对象， 构造器 new liuyi Person();
  • 对象的属性 liuyi.name;
  • 对象的方法 liuyi.sleep()

6.类：
静态的属性 属性
动态的行为 方法

2.类与对象的创建

  • 使用new关键字创建对象

    使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象，进行默认的初始化以及对类中的构造器的调用。

创建一个Student类：

package com.oop.demo02;

//学生类  （一个类里面只有属性和方法两样东西）
public class Student {

    //属性：字段
    String name; //null
    int age;  // 0

    //方法
    public void study(){
        System.out.println(this.name+"学生在学习");
        //this代表当前这个Student类；
    }

}

实例化对象：

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

        //类: 抽象的， 实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例

        Student s1 = new Student();
        Student s2 = new Student();

        s1.name = "张三";
        s1.age = 20;

        System.out.println(s1.name);//张三
        System.out.println(s1.age);//20

        s2.name = "李四";
        s2.age = 19;

        System.out.println(s2.name);//李四
        System.out.println(s2.age);//19
    }
}

3、构造器

  • 类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。一个类即使什么都不写，他也会存在一个方法，即构造方法（构造器）在IDEA中可以通过ALT+Insert快捷键选择生成构造器；并且构造器有两个特点：

    • 必须和类的名字相同
    • 必须没有返回类型，也不能写void

  • 构造器的作用

    • 使用new关键字，本质是在调用构造器
    • 构造器一般用来初始化值

  • 一旦定义了有参构造，无参就必须显式定义，这时调用会根据参数来判断是走无参还是有参

4、创建对象内存分析

5、封装

封装重点是对于属性的封装，方法很少用

  • 该露的露，该藏的藏

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

  • 封装（数据的隐藏）

    • 通常，应该禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

  • 属性私有，get/set

写一个学生类：

public class Student{
    //属性私有
    private String name;//名字
    private int id; //学号
    private char sex;    //性别
   
    //提供一些可以操作这些属性的方法
    //提供一些public的get、set方法
    
    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name=name;
    }
    
}

main方法：

public class Application{
    public static void main(String[] args){
        Student s1=new Student();
        
        s1.setName("张三");
       
        System,out.println(s1.getName());//张三
        //s1.name在这里不能使用了，因为name是private的，如果换成public则可以使用
    }
}
  • 封装的意义；
    • 提高程序的安全性，保护数据
    • 隐藏代码的实现细节
    • 统一接口
    • 提高了系统的可维护性

6、继承

  • 继承的本质是对某一批类的抽象。（类是对对象的抽象，继承是对类的抽象）
  • extends的意思是“扩展”，子类是父类的扩展。
  • JAVA中只有单继承，没有多继承。
  • 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。
  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
  • 子类和父类之间，从意义上讲应该具有“is a”的关系。
  • 子类可以继承父类的所有方法（前提是父类的方法是public修饰的）
  • 调用父类构造器必须要在子类构造器的第一行。
  • 在jiava中，所有的类，都默认直接或间接继承object类

super()注意点：

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

VS this:

  • 代表的对象不同：

    • this：本身调用者这个对象
    • super：代表父类对象的引用

  • 前提：

    • this ：没有继承也可以使用
    • super：只能在继承条件下才可以使用

  • 构造方法：

    • this ()：本类的构造
    • super()：父类的构造

7、方法重写

重写都是方法的重写，和属性无关

  • 重写：需要有继承关系，子类重写父类的方法！
    1.方法名必须相同
    2.参数列表必须相同
    3.修饰符: 范围可以扩大,但不能缩小 public>Protected>Default>private
    4.抛出的异常：范围可以被缩小，但不能扩大； ClassNotFoundException-->Exception(大)

  • 重写：子类的方法和父类必须要一致；方法体不同！

  • 为什么需要重写：
    1.父类的功能子类不一定需要，或者不一定满足！
    Alt+Insert：override；

静态方法和非静态方法区别：

  • 静态方法：方法的调用只和左边定义的数据类型有关
  • 非静态方法：重写

8、多态

  • 同一对象可以根据发送对象的不同而采用多种不同的行为方式.

  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

  • 多态的存在条件

    • 有继承的关系
    • 子类重写父类的方法
    • 父类引用指向子类对象

  • 注意：

    • 多态是方法的多态，属性没有多态
    • 父类和子类，有联系 类型转换异常，ClassCastException
    • 存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1 =new Son

  • 不能被重写的方法：

    • static 方法，属于类，它不属于实例
    • final 常量：
    • private方法

9、instanceof和类型转换

1.父类引用指向子类的对象
2.把子类转换为父类，向上转型：
3.把父类转换为子类，向下转型，强制转换
4.方便方法的调用，减少重复的代码！

10、static关键字

11、抽象类

  • abstract修饰符可以用来修饰方法也可以修饰类，如果i修饰方法，那么方法就是抽象方法；如果修饰类，那么该类就是抽象类。
  • 抽象类中可以没有抽象方法，但是抽象方法的类一定要声明为抽象类。
  • 抽象类，不能使用new关键字来创建对象，它是用来让子类实现的
  • 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

12、接口的定义与实现

  • 普通类：只有具体实现

  • 抽象类：具体实现和规范（抽象方法）都有

  • 接口：只有规范 约束和实现分离

  • 接口就是规范，定义的一组规则

  • 接口的本质是契约，就像人类定义的法规一样，制定好后大家都要遵守。

  • OO的精髓，是对对象的抽象，最能体现这一点的就是接口，声明类的关键字是class，声明接口的关键字是interface

  • java是单继承的，但是可以通过接口实现多进程

    两个接口：

    package com.oop.demo10;

public interface TimeService {
    void timer();
}

    package com.oop.demo10;

//interface 定义的关键字  ,接口都需要有实现类
public interface UserService {

   //常量~ public static final
   int AGE = 99;

   //接口中的所有定义其实都是抽象的 public abstract
    void add(String name);
   void delete(String name);
   void update(String name);
   void query(String name);
}

    接口的实现：

    package com.oop.demo10;

//抽象类 extends
//类 可以实现接口 implement 接口
//实现了接口的类，就需要重写接口中的方法

//多继承~利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

  • 接口的作用：

    • 约束

    • 定义一些方法，让不同的人实现

    • 方法都是 public abstract

    • 常量都是常量~ public static final

    • 接口不能被实例化，接口中没有构造方法

    • implements 可以实现多个接口

    • 必须要重写接口中的方法

13、内部类

  • 内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对B类来说就是外部类。

  • 内部类可分为：

    • 成员内部类

      package com.oop.demo11;

public class Outer {
private int id = 10;
public void out(){
    System.out.println("这是外部类的方法");
}

public class Inner{
    public void in(){
        System.out.println("这是内部类的方法");
    }

    //获得外部类的私有属性
    public void getID(){
        System.out.println(id);
    }
  }
}

      package com.oop;

import com.oop.demo11.Outer;

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

        Outer outer = new Outer();

        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }

}

    • 静态内部类

    • 局部内部类

      • 写在方法中的类

    • 匿名内部类

      package com.oop.demo11;

public class Test {
    public static void main(String[] args) {
      //没有名字初始化类,不用将实例保存在变量中
        new Apple().eat();
    }
}
class Apple{
    public void eat(){
    
    }
}


这篇关于面向对象编程的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！


相关编程文章

更多>
本站官方QQ
官方QQ:
23002807

沪ICP备2023033072号-1

     

扫一扫关注最新编程教程