ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

面向对象编程

2021-04-10 18:02:35  阅读:126  来源: 互联网

标签:name 子类 void 面向对象编程 父类 方法 public


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(){
          
          }
      }
      
      

标签:name,子类,void,面向对象编程,父类,方法,public
来源: https://www.cnblogs.com/ly1372/p/14641611.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有