面向对象(OOP)面向对象(OOP)

面向对象(OOP)

1.什么是面向对象

实际开发过程中,我们总是通过对象帮助我们解决问题,所以面对对象的核心本质:

找到合适的对象,帮助我们完成具体的业务.

找到合适的对象----->分析业务

搞一个合适的对象出来------->完成业务

Java在编写业务时候,采用的方式:通过对象解决.

对象就是一个个能够帮助我们解决问题的实体.Java中引用类型就是对象实例

• 对象是什么?

  ​ 类:分类/类型/类别/人类/鸟类.抽象的名字.对于具备相同外形的、相同功能的一类事物的统称。类就是对于对象的抽象(抽取对象像的部分)。

  ​ 对象：啄木鸟、黄鹂鸟等等这些就是对象。对象就是类的具象化表现形式。是能够真正帮助我们做事的。

1.1面向对象和过程的异同:

相同点:都是一种思想,思维方式,思考问题的角度.都是对软件分析设计和开发的一种思想

• 面向过程:"关注我该如何实现?"分析步骤,然后一步步实现;
• 面向对象:“关注我该找谁实现” 这个’谁’就是对象,而对象如何实现不关注;

面向对象分别为面向对象分析（OOA）、面向对象设计（OOD）和面向对象编程
（OOP）(object-oriented Analysis Design Programming )

1.2优点

1. 将复杂的问题简单化
2. 更符合生活中人们思考问题的角度
3. 面向过程更贴合执行者的思维方式,面向对象更贴合管理者的思维方式

2类与对象的概念

2.1面向对象思维方式进行编程:

为了将程序和现实生活紧密联系,提出2个概念:

• ​ 类:一系列对象的共性---->图纸|模板

• ​ 对象:用来描述现实生活中真实存在的事物------>实例

  ​ 先定义类,然后根据类创建对象

  对象和类的关系

  • 特殊到一般,具体到抽象
  • 类可看成一类对象的模板,对象可看成该类的一个具体实例.
  • 类描述同一类对象的一个抽象概念,类中定义这一类对象具有的静态动态属性
  • JDK有提供很多类,编程人员也可定义自己的类

2.2如何自定义类:

自定义类

定义类(类的组成)

• 属性 field

  • **定义该类或该类对象包含的数据(静态特征),**作用范围是整个类体.

  • 属性定义格式

    //[修饰符] 属性类型 属性名 = [默认值];
    public class Person{
        String name = "张三";
        int age = 18;
        boolean gender = false;
    }
    

• 方法 (功能) method

  • 方法用于定义该类或者该类实例的行为特征和功能实现,方法是从属于类和对象的.

  • 方法定义格式

    public class Person{
    //成员变量
    	String name;
    //成员方法
    	public void study(){
    		System.out.pringln("一个人正在学习...")
    	}
    }
    

• 构造器 constructor

  package com.shyjx.oobtest;
  public class Student {
      //属性(成员变量)
      int age;
      String name;
      boolean gender;
      //方法
      void study(){
          String i = gender?"男":"女";
          System.out.println("一个"+age+"岁的"+i+"学生"+name+"正在学习...");
      }
      //构造方法,是空构造器
      Student(){}
  }
  

  //测试类
  package com.shyjx.oobtest;
  //同包下的类不需要导包
  public class Stud_Test {
      public static void main(String[] args) {
      Student st = new Student();//创建引用对象
      st.name = "卡卡";//使用功能
      st.age = 38;
      st.gender = true;
      st.study();
      }
  }
  

• else:局部代码块|普通语句块 静态块 成员代码块|构造块 同步块 内部类

• 测试类

  • 1.导包 : 指定要使用的类型的位置    
            不需要导包的类 :        
            1.java.lang包下的类        2.同包下的类
    2.创建引用类型的对象 : new关键字就是创建对象使用的
                引用数据类型 引用名|变量名 = new 引用数据类型();
    3.使用对象的属性|功能
                引用.属性名字
                引用.功能名字(实参)
    注意 : 成员(成员变量|成员方法)是属于对象的,需要跟随对象进行属性
             成员变量只声明不赋值存在默认值  整数:0   小数:0.0   
             布尔 : false   字符:空字符   引用:null 
    注意 : 方法的返回值类型可以任意类型,包括自定义的引用数据类型(实体类型) 
    注意 :
            方法的形参的数据类型可以为自定义的引用数据类型(实体类)
    

• 工具类

• 实体类|javabean|模板类|图纸类

成员变量

2.3成员变量和局部变量的区别

备注:不同的方法中即使有同名的局部变量,没关系,互不影响,但建议相同

2.4分析共性定义实现类:

1. 分析具备的特点特征>>>属性>>>名词 通过成员变量定义

   ​ 颜色 品牌 价格等

   2.分析具备的能力和功能>>>功能>>>动词 通过成员方法定义

   ​ 打电话, 拍照等

2.5对象内存分析

JAVA中的对象和数组是通过引用对齐操作

内存划分

• 栈

  • 存放:局部变量
  • 先进先出,从上到下存储
  • 方法执行完毕,自动释放空间

• 堆

  • 存放new出来的对象
  • 需要垃圾回收器来回收

• 方法区

  • 存放:类的信息(代码) static变量 字符串常量等
    

==⭐new关键字创建对象的步骤==

1. 在堆中为对象开辟内存空间,同时类型的成员变量跟随的对象进入到堆内存中并附默认值;

2. 调用构造器为对象初始化信息;

3. 将对象的地址返回给引用.(将堆内存中的地址赋值给局部变量存储)

3.构造器(constructor)

构造器用于构造该类的实例

构造器|构造方法|构造函数 :    特殊的方法    
	作用 : 为对象初始化信息(第一次为对象的所有属性赋值),不是用来创建对象的    
	使用 : 跟随new关键字一起使用 从而返回该类的实例   
	语法 :        
		修饰符 类名(参数列表){            
   			 为对象初始化信息代码段;       
		}        
        不需要返回值类型不需要void        
        构造器的名字 必须与类名一致    
    注意 :        
        如果没有显示的定义构造器,编译器会自动提供一个空构造        
        如果存在显示定义的构造器,编译器不会再提供任何构造器,包括空构造       
        构造器是特殊的方法,可以构成重载特性 
        修饰符final  abstract static 不能用来修饰构造器
        构造器虽有返回值,但不能定义返回类型(返回值的类型肯定是本类),不能在构造器里使用带数的return语句
        以后定义实体类,一般至少提供一个空构造,根据需求提供带参,空构造在特殊场景下可以不提供,但是一般存在

注意:成员(成员属性|成员功能)是属于对象的,依赖于对象使用.

​ 因为成员变量存在于对象的堆内存中,没有new对象,就没有对象的堆内存,当然也就没有成员,因此需要跟随对象地址.

​ 在外部想要使用类中的成员,必须跟随这个类的对象使用.

​ 如果是根据对象分析出的功能,把它定义在类中的成员方法中,

​ 如果不想跟随对象使用,那就定义成静态方法,非成员方法.

3.1空构造

没有参数构造器叫做无参构造

1. 一个类里,如果没有显式|手动假如任意构造器javac编译后 自动加入空构造

2. 一旦加入构造器,javac 不会加入空构造器;

   class Dog{
   	public String name;
   	public Dog(){System.out.print("这是空构造..");}
   	//public Dog(){}//默认提供空构造
   }
   

3.2重载

一个类中可以存在多个构造器

1. 方法重载:两同三不同 同一个类方法名相同,形参类型 个数 顺序不同;
2. 构造器重载:只看形参即可 形参类型 个数 顺序不同.调用时按"就近最优原则".

public class Day006_Constructor {
    public static void main(String[] args) {
        Cat cat1 = new Cat();//创建对象
        cat1.type = "黑猫";
        cat1.color = "黄色";
		cat1.catchMouse();
        Cat cat2 = new Cat("黑猫警长");//调用一参构造器实参赋值
        cat2.catchMouse();//调用功能

        Cat cat3 = new Cat("黑猫警长","加菲",5,"蓝色");//4参构造器
        cat3.catchMouse();
    }
}

class Cat{
    public String name;//属性
    public String type;
    public int age;
    public String color;

    public Cat(){
        System.out.println("这是空构造...");//首先输出这是空构造...
    }
    public Cat(String catName){
        System.out.println("一参构造器...");//重载
        name = catName;
    }
    public Cat(String catName,String catType,int catAge,String catColor){
        System.out.println("4参构造器..");
        name = catName;
        type = catType;
        age = catAge;
        color = catColor;
    }
    public void catchMouse(){//功能
        System.out.println(color+name+"抓老鼠...");
    }
}//输出结果如下:
        /*这是空构造...
        黄色黑猫抓老鼠...
        一参构造器...
        null黑猫警长抓老鼠...
        4参构造器..
        蓝色黑猫警长抓老鼠...*/

4.this关键字

/*
    this : 即"自己",指代当前对象,谁调用代表谁.
        1)在构造器的首行通过this(实参)调用本类中的其他构造器
        2)区分同名的成员与局部问题
            默认就近原则找最近的,有局部找局部,没有局部找成员
            如果出现同名问题,想要调用成员,通过this.调用
            如果不存在同名问题,想要调用成员,可以省略this.
            this在构造器中指代当前new的对象
            this在成员方法中指代调用成员方法的对象

        注意 : 多个构造器之间不能通过this相互调用
               this不能用在静态方法|环境中
 */
public class Teacher {
    public static void main(String[] args) {
        Teach t = new Teach("小英",18,false);
        t.preach();
        //System.out.println(t);
    }
}
class Teach{
    public String name;//属性
    public int age;
    public boolean gender;
    //空构造
    public Teach(){}
    //2参构造器
    public Teach(String name,int age){
        this.name = name;
        this.age = age;
    }
    public Teach(String name,int age,boolean gender){//3参构造器
        this(name,age);//调用本类其他构造器
        this.gender = gender;
    }
    //功能
    public void preach(){
        String i = gender?"男":"女";
        System.out.println("一位年纪"+age+"岁的"+i+name+"老师"+"正在传道授业解解惑...");
    }
}

5.static关键字

/*
    static :静态的
        成员修饰符,只能修饰成员,不能修饰局部的
        static修饰成员变量--> 静态变量|类变量
        static修饰成员方法--> 静态方法|类方法
        static修饰块 --> 静态块
        static修饰类 --> 静态内部类

        static修饰的变量与方法的使用 :
            对象.静态变量
            对象.静态方法(实参)
            类名.静态变量  --> 推荐
            类名.静态方法  --> 推荐

        静态的是属于类的,成员的是属于对象的
        加载初始顺序 : 先静态后成员
        静态变量在类第一次加载到内存之后就进行初始化
        成员变量是属于对象的,因为存在与对象的堆内存中,静态变量是属于类的,存在与静态区中,与对象的堆内存无关,是独一份的
        静态内容是所有当前类型对象共享的

   划分 :
    成员位置定义内容都是成员
    成员变量 :
        被static修饰的成员变量 : 静态变量|类变量
        不被static修饰的成员变量 : 成员变量|实例变量
    成员方法 :
        被static修饰的成员方法 : 静态方法|类方法
        不被static修饰的成员方法 : 成员方法|实例方法

   调用静态内容时候的区别 :
        1.如果在静态方法中调用,可以直接调用静态内容,但是需要通过对象调用成员内容
        2.如果在成员方法中调用,可以直接调用成员内容,可以直接调用静态内容

 */
public class T1 {
    static int i = 1;//静态变量
    int j = 2;//成员变量
    public static void main(String[] args) {
        //静态的内容可以直接用
        System.out.println("i1="+i);//i1=1
        System.out.println("i2="+T1.i);//i2=1
        test();//调用静态方法
        T1 t = new T1();//通过对象使用成员
        System.out.println("j="+t.j);//j=2
        t.test2();//调用成员方法,i=5,j=1

    }
    //静态方法
    public static void test(){
        i++;
        System.out.println(i);
    }
    //成员方法 使用静态和非静态内容
    public void test2(){
        i+=3;//非静态方法中可以通过对象使用,直接使用成员内容
        j--;
        System.out.println(i);
        System.out.println(j);
    }
}

静态与成员的定义分析:

/*
	静态与成员的定义分析 :
		1.从逻辑上分析,必须依赖对象才能使用的属性,功能,必须定义为非静态的成员
					  如果不需要依赖于对象,没有对象也能够使用的,定义为静态的
		2.定义静态或者成员都可以的情况 : 为了使用简单,推荐定义为静态的
 */

5.1 内存分析

5.2 静态调用的过程和区别

• static调用非static ： 一定要创建对象
• static调用static ： 直接调用
• 非static 调用static： 直接调用
• 非static调用非static：直接调用

静态内容隶属于类，非静态内容隶属于对象；

一个类在被主动时候用时，会被加载到内存中之后，而加载到内存中之后，当前类的所有的静态内容会在内存中生成一份；

也就是说，类被加载了，对象不一定存在，而对象存在，类一定被加载了。

补充：类的主动使用

1： 调用了当前类的main方法，或者说当前类是启动类；

2： 调用了当前类的静态内容，不管是静态方法、还是静态属性；

3： 创建了当前类的实例对象；

4： 创建子类对象的时候，父类也会被加载

6.block与debug

6.1 block

块{} 在java中自成作用域,分为以下:

注意:

• 同一个作用域内变量不能同名
• 当存在多个构造块,会从上到下执行所有构造块的代码,先于构造器代码之前执行,每创建一个对象执行一次
• 当存在多个静态块,从上到下依次执行
• 如果代码中存在构造块,编译时编译器会将构造块中的代码编译到即将要执行的构造器的内部,构造器代码上面
• 静态初始化块中不能访问非static成员
• 类第一次载入时先执行static代码块(静态块);多次载入时,static代码块只执行一次;static块经常用来进行static变量的初始化
• 是在类初始化时执行,不是在创建对象时执行

6.2 debug

/*
	Debug : 调试工具
		作用 :
			1.追踪程序的执行流程
			2.观察程序执行过程中变量的变化的情况
			3.通过追踪程序执行流程学习第三方框架的源码
			4.快速的通过debug定位问题|异常出现的位置

		使用 :
			1.设置断点
			2.debug模式运行
				Step Over F8 : 继续执行下一行,当是方法的调用,也不跟随执行直接继续下一行
				Step Into F7 : 步入|继续执行下一行,当是自定义的方法的调用,会进入方法跟随执行
				Force Step Into alt+shift+F7 : 强制步入|继续执行下一行,当是jdk的源码方法的调用,也会强制进入方法跟随执行
				Step Out shift+F8 : 下一步跳出,如果在方法的内部,直接调出到方法调用出
				Run to Cursor alt+F9  运行到光标所在位置
 */

7.面向对象-封装(encapsulation)

装个盒子。 通过权限修饰符来确保当前的类、方法、变量在什么情况下可见的一种手段。

7.1 封装的作用含义

需要让用户知道的暴露出来,不需要让用户了解的全部隐藏起来. 这就是封装.

白话:该露的露,该藏的藏

专业:程序设计追求"高内聚,低耦合".高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用.

/*
    为了解决数据安全问题 :
        介绍一个关键字 private 私有的
        private是一个成员修饰符,只能修饰成员不能修饰局部
            访问权限,使用private修饰的成员被访问的权限为 : 只能在当前类中访问

        私有的属性在使用时,需要同时提供公共的访问方式
            设置器 setter : 为私有属性设置值
            访问器 getter : 获取私有属性的值

    注意 : 以后定义实体类中所有的属性,一般都设置为私有的,并同时提供一对公共的访问方式

    封装 :
        面向对象三大特性之一

        隐藏内部的实现细节,对外提供公共的访问方式
            封装是私有,私有是封装
                封装不仅仅是私有,类,方法,属性私有化等都是封装具体的体现

        优点 :
           提高代码的安全性
           提高代码复用性,便于调用,便于修改内部代码,提高可维护性,可进行数据完整性检测,保证数据有效性

    Javabean : 实体类的统称,符合Javabean类型定义规范的类称之为Javabean
        1.类是公共的
        2.至少提供一个空构造
        3.私有的属性
        4.公共的访问方式
        5.重写toString方法
 */

7.2 访问控制符,实现封装(封装的关键词)

7.3 封装的使用细节

类的属性的处理:

一般使用private。 (除非本属性确定会让子类继承)

提供相应的get/set方法来访问相关属性. 这些方法通常是public，从而提供对属性的读取操作。 （注意：boolean变量的get方法是用：is开头!）

JavaBean对象

Javabean : 实体类的统称,符合Javabean类型定义规范的类称之为Javabean
        1.类是公共的
        2.至少提供一个空构造
        3.私有的属性
        4.公共的访问方式
        5.需要重写toString方法
          set+属性名首字母大写 -> 带参，无返回值
          get+属性名首字母大写-> 无参，有返回值    boolean   is+属性名首字母大写

以上是面向对象基础部分和封装简介的内容介绍,三大特性稍后分享,谢谢!
***

> 每一份看起来的毫不费力,背后都是用尽全力

......***

最后

以上就是昏睡芹菜为你收集整理的面向对象(OOP)面向对象(OOP)的全部内容，希望文章能够帮你解决面向对象(OOP)面向对象(OOP)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。