java 面向对象落地法则

Daniels_Shelby
224 阅读8分钟

面向对象:

一. 面向对象的编程关注于类的设计

1. 一个项目或工程, 不过多庞大, 一定是有一个一个类构成的
2. 类是抽象的, 好比是制造汽车的图纸. 二聚体的一辆一辆的车, 是根据图纸制造的, 实际上就是类的实例化
3. 类的组成成分
	①. 属性 (成员变量, Field)
    	②. 方法 (成员方法, 函数, Method)
4. 类的初始化和内存的解析
	内存划分的结构:
  	栈(stack): 局部变量、对象的引用名. 数组的引用名
  	堆(heap): new 出来的"东西" (如:对象的实体, 数组的实体), 含成员变量
  	方法区: 含字符串常量
  	静态域: 声明为 static 的变量
5. 类的关系:
	① 从代码的角度:
    	并列关系
    ② 从执行、设计的角度:
    	关联关系、继承关系、聚合关系

二. 完成一个项目(或功能)的思路

1. 所要完成的功能对应的类的对象是否已经存在
2. 若存在, 则通过对象直接调用对应的类中的属性或方法即可
3. 若不存在, 则需要创建类的对象, 甚至说, 类都不存在, 就需要设计类

三. 面向对象编程的三条主线

1. 类及类的构成成分: 属性 方法 构造器 代码块 内部类
2. 面向对象编程的特征: 封装性 继承性 多态性 (抽象类)
3. 其他关键字: this super package import static final abstract interface ...

四. 面向对象的落地法则

1. 设计类, 并设计类的成员(成员变量&成员方法)
2. 通过类, 来创建类的对象(类的实例化)
3. 通过 "对象.属性" 或 "对象.方法" 来调用, 完成相应的功能

五. 创建对象

创建的多个对象彼此各自都拥有一套类的属性. 当对其中一个对象的属性进行修改时, 不会影响到其他对象的属性值.

进入正题

一. 类的成员之 属性(成员变量)

成员变量 & 局部变量

相同点: 
	1. 遵循变量声明的格式:	数据类型 变量名 = 初始值
	2. 都有各自的作用域

不同点:
    1. 声明的位置不同: 
	成员变量: 声明在类里, 方法外
	局部变量: 声明在方法内, 方法的形参部分, 代码块内
    
    2. 	成员变量的修饰符有四个: public private protected 缺省
    	局部变量没有修饰符, 与所在的方法修饰符相同
        
    3.	初始化值: 一定会有初始化值
    	成员变量: 如果在声明的时候, 不显式赋值, 那么不同数据类型会有不同的默认初始化值.
           byte short int long ==> 0
           float double ==> 0.0
           char ==> 空格
           boolean = false
           引用类型变量 ==> null
        局部变量: 一定要显式赋值. (局部变量没有默认初始化值)
        
    4. 二者在内存中存储的位置不同
    	成员变量: 存在于堆空间中
        局部变量: 存在于栈空间中
总结:
    关于变量的分类: 
    	① 按照数据类型的不同: 基本数据类型(8种) & 引用数据类型
        ② 按照声明的位置的不同: 成员变量 & 局部变量
        
类对象的属性的赋值顺序:
	① 属性的默认初始化
        ② 属性的显式初始化
        ③ 通过构造器给属性初始化
        ④ 通过"对象.方法"的方式给属性赋值

二. 类的成员之 方法: 提供某种功能的实现

1 实例: public void eat(){}
	public String getName(){}
    	public void setName(String name){}
  格式: 权限修饰符 返回值类型(void:无返回值/具体返回值) 方法名(形参){方法体}

2. 关于返回值类型:	void: 表示此方法不需要返回值
			有返回值方法, 在方法的最后一定又return + 返回值类型对应的变量
            
3. 方法内可以调用本类的其他方法或属性, 但是不能在方法内再定义方法

三. 类的成员之 构造器(构造方法)

        声明:	权限修饰符 类名(形参){}
            
        作用:	1. 创建对象 
        	2. 初始化对象的属性
        
        使用:
        	1. 设计类时, 若不显式声明类的构造器的话, 程序会默认提供一个空参的构造器
            	2. 一旦显式的定义类的构造器, 那么默认的构造器就不再提供
            	3. 类的多个构造器之间构成重载

四. 类的成员之 初始化块(代码块)

1. 代码块如果有修饰符的话, 那么只能使用 static
2. 分类
	① 静态代码块
    	Ⅰ. 随着类的加载而加载, 而且只加载一次
        Ⅱ. 里面可以有输出语句
        Ⅲ. 多个静态代码块之间按照顺序结构执行
        Ⅳ. 静态代码块的执行要早于非静态代码块 的执行
        Ⅴ. 静态代码块中只能执行静态的结构(类属性, 类方法)
    ② 非静态代码块
    	Ⅰ. 可以对类的属性(静态的 & 非静态的)进行初始化操作, 同时也可以调用本类声明的方法(静态的 & 非静态的)
        Ⅱ. 里面可以有输出语句
        Ⅲ. 一个类中可以有多个非静态代码块, 多个代码块之间按照顺序结构执行
        Ⅳ. 每创建一个类的对象, 非静态代码块就执行一次
        Ⅴ. 非静态代码块的执行要早于构造器
        

关于属性赋值的操作:
	1. 默认初始化
	2. 显式的初始化或代码块初始化(此处两个结构按照顺序执行)
    3. 构造器中
    4. 通过方法对对象的相应属性进行修改

五. 类的成员之 内部类

1. 相当于说 我们可以在类的内部再定义类. 外面的类: 外部类. 里面的类: 内部类
2. 内部类的分类: 
	成员内部类(声明再类内部且方法外的)
    	① 是外部类的一个成员:
        	Ⅰ. 可以有修饰符
            Ⅱ. static final
            Ⅲ. 可以调用外部类的属性方法
        ② 具有类的特点
        	Ⅰ. abstract
            Ⅱ. 还可以在其内部定义属性、方法、构造器
    
    局部内部类(声明在类的方法里)
3. 掌握三点:
	① 如何创建成员内部类的对象
    ② 如何区分调用外部类、内部类的变量
    ③ 局部内部类的使用

六. 方法的重写(overwrite)

1. 前提: 有子类继承父类
2. 子类继承父类以后, 若父类的方法对子类不适用, 那么子类可以对父类的方法重写
3. 重写的规则: 
	① 要求子类方法的"返回值类型 方法名(参数列表)"与父类的方法一样
        ② 子类方法的修饰符, 不能小于父类方法的修饰符
        ③ 若父类方法抛出异常, 那么子类方法抛出的异常类型不能大于父类的
        ④ 字符类的方法必须同为static或同为非static

七. 方法的重载(overload)

要求:
    1. 同一个类中
    2. 方法名必须相同
    3. 方法的参数列表不同(①参数个数不同 ②方法的类型不同)
    
补充: 方法的重载与方法的返回值类型没有关系

八. 匿名类对象: 创建的类的对象是匿名的

1. 当我们只需要使用一次调用类的对象时, 我们就可以考虑使用匿名的方式创建类的对象.
2. 特点: 创建的匿名类的对象只能够调用一次

九. 可变个数的形参的方法:

1. 格式: 对于方法的形参: 数据类型 ... 形参名
2. 可变个数的形参的方法与同名的方法之间构成重载
3. 可变个数的形参在调用时, 个数从0开始, 到无穷多个都可以
4. 使用可变多个形参的方法与方法的形参使用数组是一致的
5. 如果方法中存在可变个数的形参, 那么一定声明在参数的最后
6. 在一个方法中, 最多声明一个可变个数的参数

十. 方法的参数传递(重难点)

1. 	形参: 方法生命是, 方法小括号内的参数
	实参: 调用方法时, 实际传入的参数的值
    
2. 规则: java中的参数传递机制: 值传递机制
	1. 形参是基本数据类型的: 将实参的值传递给形参的基本数据类型的变量
    	2. 形参是引用数据类型的: 将实参的引用类型变量的值(对应的堆空间的对象实体的首地址值)传递给形参的引用类型变量

十一. 权限修饰符

修饰符类内部同一个包子类任何地方
privateyes
defaultyesyes
protectedyesyesyes
publicyesyesyesyes

对于class的权限修饰符只可以用 public 和 default(缺省)

public 类可以在任意地方被访问

default 类只可以被同一个包内部的类访问

avatar
文章
阅读
粉丝