目录 :
1 ) . 面向对象(概述)
2 ) . 面向对象(举例)
3 ) . 面向对象(类与对象的关系)
4 ) . 面向对象(成员变量与局部变量)
5 ) . 面向对象(匿名对象的应用)
6 ) . 面向对象(封装-概述)
7 ) . 面向对象(封装private)
8 ) 面向对象(构造函数)
9 ). 面向对象(构造代码块)
10 ). 面向对象(this关键字)
11 ). 面向对象(this关键字的应用)
12 ). 面向对象(this关键字在构造函数间调用)
13 ). 面向对象(static关键字)
14 ) . 面向对象(main函数)
15 ). 面向对象(静态什么时候使用)
16 ). 面向对象(静态的应用-工具类)
17 ). 面向对象(帮助文档的制作javadoc)
18 ). 面向对象(静态代码块)
19 ). 面向对象(对象的初始化过程)
20 ). 面向对象(对象调用成员过程)
21 ). 面向对象(单例设计模式方式一)
22 ). 面向对象(单例设计模式方式二)
一
. 面向对象(概述)
1 ) . 相关要点 :
1.1 面向对象概念
1.2 类与对象的关系
1.3 封装
1.4 构造函数
1.5 this关键字
1.6 static关键字
1.7 单例设计模式
2 ) . 面向对象概念 :
2.1 理解面向对象
[1] 面向对象是相对面向过程而言
[2] 面向对象和面向过程都是一种思想
[3] 面向过程-->强调的是功能行为
[4] 面向对象-->将功能封装进对象,强调具备了功能的对象
[5] 面向对象是基于面向过程的
2.2 面向过程与面向对象的区别 :
[1] 面向过程强调功能命令,面向对象强调对象实体
[2] 从面向过程到面向对象是复杂程度简单化的过程,也可以理解为对象是一种特定的结果,而过程是对细节的定义
[3] 万物皆对象,也可以理解为你所看到的可以定义的一切都是对象
小结 :
1. 功能封装成实体,封装功能是面向过程,操作实体是面向对象的,面向对象开发就是依据对象找功能 !
二. 面向对象(举例)
1 ) . 案例理解 :
1.1 案例理解一 : 冰箱的打开存储关闭的过程 --> 行为方式
[1] 面向过程 : 打开冰箱--> 存储货物进冰箱--> 关闭冰箱 : 操作的功能 -->执行者
[2] 面向对象 : 冰箱打开--> 冰箱存储 -- > 冰箱关闭 : 操作的对象 --> 指挥者
1.2 案例理解二 : 如何在沙漠里种水稻? -->思维方式[1] 面向过程 : 查阅资料--> 学习技术-->计划准备 -->风险预估 --> 开始实施 --> 流程控制 --> 质量管理 --> 完成操作 : 风险很大,因为 技术不一定成熟
[2] 面向对象 : 寻找专家--> 风险评估 --> 成 : 交由办理 ; 不成 : 及时 止损 ,退出 ! --> 成 : 成本验收 --> 完成操作 : 风险较小 ,因为 从内部依赖到外部
1.3 案例理解三 : 一家知名互联网公司解决员工餐饮问题? : 内部管理成本--> 外部的交易成本
[1] 面向过程 : 招募员工 --> 前期培训 --> 成本控制--> 人员分配 --> 店铺入驻 --> 流程控制--> 质量管理--> 日常行为 : 开饭啦 --> 饭菜反馈...
[2] 面向对象 : 寻找优质平台 --> 进行合作--> 商家入驻 --> 日常行为 : 开饭啦 --> 饭菜反馈--> 平台商家调整
2 ) . 面向对象对应到程序的理解 :
2.1 我们开发时不是先定义功能,而是先寻找对象,站在巨人的肩膀上会看的更远
2.2 我们开发时不是先定义功能,而是先定义对象, 以结果为导向的开发会更便捷
2.2 我们开发时最后再 定义功能,而后完成功能封装进对象,完成接口抽取调用
小结 :
1. 我们是依据对象找功能,而不是依据功能找对象
三. 面向对象(类与对象的关系)
1 ) . 案例提炼 : 人开门 -->名词提炼法
1.1 人 -->对象
[1] .开() : 方法-->调用动作(接口)
1.2 门 -->对象
[1] 开() : 操作门轴,扇叶等 -->动作(功能)
2 ) . 面向对象的三大特征 :
2.1 特征--> 以不同的维度去描绘一个实体,使你的脑海中形成影像的一种方式
2.2 三大特征 :
[1] 封装
[2] 继承
[3] 多态
3 ) . 类和对象的关系 :
3.1 类 : --> 对现实生活中事物(对象)的描述
3.2 对象 : ---> 就是这类 事物,实实在在存在的个体
3.3 关系 : --> 相对于计算机而言,先有类后有对象;相对于开发而言,先有对象,后有类
3.4 提取 : --> 提取不同对象的共性特征,即为对具体的抽象(抽的是类型,特征)
3.5. 映射到java: --> 描述就是class定义的类,具体对象就是对应java在堆内存用new建立的实体 --> 描述事物就是在描述事物的属性(变量)和行为(方法),也就是java中的定义类
4 ) . 关系案例解析: 图纸 和 汽车
4.1 图纸 --> 用来描述汽车的类
4.2 汽车 --> 依据描述建造的实体
5 ). 事物的两部分 : 属性(变量) ,行为 (函数,方法) ,共同是java类中的成员(成员变量,成员函数)
6 ). 基本操作简述 :
6.1 Car c=new Car() ; --> C就是一个类类型变量, 指向实体(对象) --> 类类型对象通过内存地址值操作使用堆内存当中的实体
6.2 c.color="red"; --> 更改对象属性的方式 : 对象.对象成员变量 ="新值" ;
6.3 c.run(); --> 调用行为(方法)的方式 : 对象.对象成员函数() ;
小结 :
1. 开发就是不断寻找对象的过程,若没有对象,即创建对象 --> 找对象,建对象,用对象,并维护对象之间的关系2. 何为对象? --> 对象就是多个功能的封装,在java中如何产生对象,即为 new
3. java中可以通过多个引用指向同一个对象,对象的特点在于封装数据,也就是封装属性
四. 面向对象(成员变量与局部变量)
1 ) . 成员变量与局部变量的区别 :
1.1 作用域的不同 : --> 成员变量作用于整个类,而局部变量作用于方法(函数)或语句中
1.2 内存存储位置的不同 : --> 成员变量存储在堆内存中,因为对象的存在而存在;而局部变量存在于栈内存中
五
. 面向对象(匿名对象的应用)
1 ) . 简述 : --> 匿名对象就是对象的简化形式
2 ) . 匿名对象的两种使用情况 :
2.1 当对对象仅进行一次调用时
2.2 匿名对象可以作为实际参数进行传递
3 ) . 匿名对象与实体对象javad代码的区别 :
3.1 实体对象 : Car c = new Car(); c. num =5 ;
3.2 匿名对象 : new Car().num=5 ;
3.3 匿名对象调用方法时有意义,而调用属性是没有意义的,如同 造汽车没人用一样,没价值
小结 :
1. 匿名对象与实体对象之间的区别在于没名字
六. 面向对象(封装-概述)
1 ) . 简述 :
1.1 概念 : 指隐藏对象的属性和实现细节,仅对外提供公共访问方式
1.2 好处 :
[1] 将变化隔离
[2] 便于使用
[3] 提供重中性
[4] 提高安全性
1.3 封装原则 :
[1] 将不需要对外提供的内容隐藏起来
[2] 把属性都隐藏,提供公共方法对其访问
小结 :
1. 使用框架无需了解原理,而封装框架需要了解原理
七. 面向对象(封装private)
1 ) . private :
1.1 概念 : 是一个私有,权限修饰符 --> 用于修饰类中的成员(成员变量,成员函数)
1.2 作用域 : 被私有化的成员变量仅在本类中有效 ,就算外界建立了对象也不能直接访问
1.3 访问方式 : 封装进方法
1.4 常用之一 : 将成员变量私有化,对外提供对应的set,get方法对其进行访问,提高对数据访问的安全性
小结 :
1. 私有化仅仅是封装的一种表现形式,另对外提供访问方式是,可在访问方式(方法)中进行逻辑判断,提高代码的健壮性
八
. 面向对象(构造函数)
1 ) . 特点 :
1.1 函数名与类名相同
1.2 不用定义返回值类型
1.3 不可以写return语句
2 ) . 作用 : 给对象进行初始化
3 ) . 注意 :
3.1 默认构造函数的特点
3.2 多个构造函数是以重载的形式存在的
4 ) . 构造函数和一般函数的区别?
[1] 写法的不同
[2] 运行上的不同,构造函数在对象一建立就运行,给对象初始化,而一般函数在对象调用才执行,给对象添加应具备的功能
[3] 操作次数的不同,构造函数只运行一次,而一般函数可以被对象调用多次
5 ). 何时定义构造函数? --> 当分析事物时,该事物存在具备一些特征或者行为,那么这些内容定义在构造函数中
小结 :
1. 对象一建立就会调用与之对应的构造函数,用来给对象进行初始化2. 当类中没有定义构造函数时,系统会默认给类加入一个空参的构造函数 ;当类中定义了构造函数时,默认的构造函数消失
九 . 面向对象(构造代码块)
1 ) . 作用 : 给对象进行初始化,在对象建立时就运行,而且优先于构造函数执行
2 ) . 构造代码块与构造函数的区别 : 构造代码块作用于同一类中的所有对象,而构造函数是作用于相对应的对象
3 ) . 构造函数中定义抽取的的是不同对象中共性的初始化内容
十. 面向对象(this关键字)
1 ) . this : --> 看上去,是用来区分局部变量和成员变量同名情况
2 ) . this 代表本类对象,具体代表它所在函数所属对象的引用--> 通俗讲 哪个对象在调用this所在的函数,this就代表哪个对象
十一. 面向对象(this关键字的应用)
1 ) .当类中定义功能,该函数内部要用到调用该函数的对象时, 这时用this来表示这个对象
2 ) . 但凡本类功能内部使用了本类对象,都要用this表示
十二
. 面向对象(this关键字在构造函数间调用)
1 ) . this语句 : 用于构造函数之间进行互相调用
2 ) . this语句只能定义在构造函数的第一行,因为初始化要先执行
3 ). this函数的两种用法,一种用来区分成员与局部变量,一种用来构造函数之间互相调用
小结 :
1. this不能出现在一般函数中,只能出现在构造函数间
十三
. 面向对象(static关键字)
1 ) . 简述 :
1.1 概念 : 用于修饰成员(成员变量和成员函数)
1.2 被修饰后的成员具备以下特点 :
[1] 随着类的加载而加载,随着类的消失而消失,说明它的生命周期最长
[2] 优先于对象存在,意思是 静态先存在,对象而后存在
[3] 被所有对象所共享
[4] 可以直接被类名调用
1.3使用注意 :
[1] 静态方法只能访问静态成员-->非静态方法既可以访问静态也可以访问非静态
[2] 静态方法中不可以定义this.super关键字 -->因为静态优先于对象存在,因此静态方法中不可以出现this
[3] 主函数是静态的
2 ) . 方法区/共享区/数据区 --> 内存 类中的方法和类中的共享数据
3 ) . 成员变量=实例变量 ; 静态的成员变量=类变量
4 ) . 实例变量和类变量的区别:
[1] 存放位置 --> 类变量随着类的加载存在于方法区中,实例变量随着对象的建立而存在于堆内存中
[2] 生命周期 -- > 类的生命周期最长,随着类的消失而消失; 实例变量生命周期随着对象的消失而消失
5 ). static 的好处和弊端 :
[1] 好处 : 对对象的共享数据进行单独空间的存储,节省空间,没必要在每一个对象中都存一份 ; 可以使用类名直接调用
[2] 弊端 : 生命周期过长 ;访问出现局限性(静态只能访问静态)
小结 :
1. 特有数据随着对象在堆内存中存储2. 被静态修饰后的变量不仅可以被对象调用,还可以被类直接调用
十四. 面向对象(main函数)
public static void main (String[] args)
1 ) . 简述 : 主函数 --> 是一个特殊的函数,作为程序的入口,可以被jvm调用 ; 主函数的格式是固定的,由jvm识别
2 ) . 主函数的定义 :
[1] public : 代表着该函数的访问权限是最大的
[2] static : 代表主函数随着类的加载就已经存在了
[3] void : 主函数没有具体的返回值
[4] main : 不是关键字,但是是一个特殊的单词,可以被jvm识别
[5] (String[] args) ; 函数的参数,参数类型是字符串类型的数组,也指数组中的元素是字符串 ; jvm 在调用主函数时,传入的是new String[0];
小结 :
1. 主函数中可以传入参数,默认传入的是 java运行时传入的类名,打印出来的是类数据地址
十五. 面向对象(静态什么时候使用)
1 ) . 何时使用静态 ? 从两方面下手 : 成员变量和函数
2 ) . 何时定义静态变量(类变量)? --> 当对象中出现共享数据时,该数据被静态所修饰 ,静态汇总的特有数据要定义成非静态存在于堆内存中
3 ) . 何时定义静态函数? --> 当功能内部没有访问到非静态数据(对象的特有数据),那么该功能可以定义成静态的
十六
. 面向对象(静态的应用-工具类)
1 ) . 简述 : 每一个应用程序中都有共性的功能,可以将这些功能进行抽取,独立封装,一遍复用
2 ) . 建立ArrayTool工具类对数组进行操作的常见问题 :
[1] 对象是用于封装数据的,可是ArrayTool对象并未封装特有数据
[2] 操作数组的每个方法都没有用到ArrayTool对象中的特有数据,因为可以将ArrayTool的方法定义为static,直接通过类名调用
[3] 方法静态后以便于使用,但是该类该可以通过其他程序建立对象,为了严谨,让其不能建立对象,可以通过构造函数私有化完成
3 ) . 代码示例 :
class ArrayText{public static void main(String[] args){int[] arr={1,2,3,4,2,3,2,3,2,3,12};int max=ArrayTool.getMax(arr);ArrayTool.bubbleSort(arr);ArrayTool.printArray(arr);//System.out.print(arr);}}class ArrayTool{//私有化无参构造,使其不能创建对象private ArrayTool(){};//获取最大值//1.返回值 int//2.参数列表 int[]public static int getMax(int[] arr){int max=0;for(int i=1;i<arr.length;i++){if(arr[i]>arr[max])max=i;}return arr[max];}//获取最小值//1.返回值 int//2.参数列表 int[]public static int getMin(int[] arr){int min=0;for(int i=1;i<arr.length;i++){if(arr[i]<arr[min])min=i;}return arr[min];}//查询排序//1.返回值void//2.参数列表 int数组public static void bubbleSort(int[] arr){for(int i=0;i<arr.length-1;i++){for(int y=0;y<arr.length-i-1;y++){if(arr[y]>arr[y+1]){swap(arr,y,y+1);}}}}//交换//1.没有返回值void//2.参数列表 数组和两个int参数private static void swap(int[] arr ,int a,int b){int temp=arr[a];arr[a]=arr[b];arr[b]=temp;}//输出数组//1.返回值没有void//2.参数列表 数组intpublic static void printArray(int[] arr){System.out.print("[");for(int i=0;i<arr.length;i++){if(i!=arr.length-1)System.out.print(arr[i]+",");elseSystem.out.print(arr[i]+"]");}}}
十七
. 面向对象(帮助文档的制作javadoc)
1 ) . 步骤 :
1.1 第一步 : 编写工具类,并在类上/方法上/使用 文档注释标注
1.2 第二步 : 进入 dos窗口. 通过 命令 : javadoc -d 指定目录名 -author -version java文件 ---用来 生成 java帮助文档 ;
示例 : javadoc -d MyHelp -author -version ArrayTool.java
2 ) . 帮助文档=说明文档=API文档
小结 :
1. 默认构造函数的权限是随着类权限的变化而变化的2. API帮助文档就是通过javadoc制作的
十八. 面向对象(静态代码块)
1 ) . 静态代码块格式 :
static{静态代码块中的执行语句}
2 ) . 静态代码块特点 : --> 随着类的加载而执行,只执行一次,用来给类进行初始化的
小结 :
1. 静态代码块给类初始化,构造代码块给对象初始化,构造函数给对应对象初始化
十九. 面向对象(对象的初始化过程)
1 ) . 创建对象的初始化过程 : Person person =new Person("张帅",20);
1.1 第一步:因为new 用到了class文件,因此 class文件通过jvm加载进内存 , person名入栈 , 实体对象入 堆 并开辟空间
1.2 第二步 : 静态代码块被执行,若有的话,那么就会给Persion.class类进行初始化
1.3 第三步 : 在堆内存中开辟空间,分配内存地址
1.4 第四步 : 在堆内存中建立对象的特有属性,并进行默认初始化
1.5 第五步 : 对属性进行显示初始化
1.6 第六步 : 对对象进行构造代码块初始化
1.7 第七步 : 对对象进行对应的构造函数 初始化
1.8 第八步 : 将内存地址赋给栈内存中的P变量
二十
. 面向对象(对象调用成员过程)
1 ) . 堆区:
1.1 存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
2 ) . 栈区 :
2.1.每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中
2.3 栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
3 ) . 方法区:
3.1.又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。
3.2.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。
4 ) . 大白话解释栈,堆和方法区 :
4.1 栈存放的大多是索引(对象名,方法名,参数名)等局部变量,在栈内多用来交易的场所,也可以理解为存放的相关特定标识符用以交易
4.2 堆存放的是对象实体等成员实例变量,在堆内多用来存放重量级的东西,可以理解为仓库, 从栈内找索引,调取堆内的对象的
4.3 方法区内存放的是 方法的主体等类基本信息,常量,静态成员变量,(构造方法,final方法,static静态方法,abstract抽象方法,public ,private,protected 控制方法,native其他语言实现的本地方法, synchronized同步方法 )
小结 :
1. 非静态前省略this. 静态前省略的是 类名.2. 非静态方法(有访问权限的方法)可以访问静态方法(全局方法),但静态方法不可以访问非静态
二十 一. 面向对象(单例设计模式方式一)
1 ) . 名词解释 :
1.1 设计模式 :
[1]解释 : --> 指对某种问题行之有效的解决方式(方法),是一种思想,一种解决问题的思考方式
[2] 目的 : --> 让复杂的事情简单化
[3] 框架 : --> 框架是 多种设计模式的整合优化产生的结晶
[4] 吃饭的设计模式:--> 中国 : 筷子 ; 欧美 : 刀叉 !
1.2 java中23种设计模式之一 : 单例模式
[1] 解释 : --> 解决一个类在 内存中只存在一个对象, 也就是解决唯一性的问题
[2] 思想 : --> 如何保证对象唯一
① 为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象
② 为了让其他程序可以访问到该类对象,只好在本类中,自定义一个对象
③ 为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式
[3] 步骤 : -- > 如何用代码实现?
① 将构造函数私有化
② 在类中创建一个本类对象
③ 提供一个方法可以获取到该对象
2 ) . 单例模式代码:
class SingleDemo{public static void main(String[] args){//通过类调取实例化对象方法从而实现对象的创建Single ss=Single.getInstance();}}
class Single{//私有的无参构造private single(){}//创建一个私有化静态对象private static Single s =new Single();//创建一个私有化的实例化对象方法public static Single getInstance(){return s;}}
3 ) . 获取方法的两种方式 :
3.1 通过对象的方式调用
3.2 通过类的方式调用
4 ) . 单例模式验证代码:
class SingleDemo{//验证是否对象唯一,采用设值的方式,使用对象1进行设值,然后通过对象2进行调取,看看是否取得是设的值,若是则说明是同一对象public static void main(String[] args){//通过类调取实例化对象方法从而实现对象的创建// Single ss=Single.getInstance();//通过new的方式创建对象// Single s1 = new Single();// Single s2 = new Single();//通过实例化方法创建对象Single s1= Single.getInstance();Single s2= Single.getInstance();s1.setNum(23);System.out.println(s2.getNum());}}class Single{//测试传入值private int num;public void setNum(int num){this.num=num;}public int getNum(){return num;}//私有的无参构造private Single(){}//Single(){}//创建一个私有化静态对象private static Single s =new Single();//创建一个私有化的实例化对象方法public static Single getInstance(){return s;}}
小结 :
1. 对于事物该怎么描述还怎么描述,当需要将该事物的对象保证在内存中唯一时,就将以上的三步加上即可
二十 二. 面向对象(单例设计模式方式二)
1 ) . 对比代码 :
/*先初始化对象称为 : 饿汉式--> single类一进内存,就已经创建好了对象后初始化对象称为 : 懒汉式--> Single类一进内存,需要采用双重判断是否为null后再进行创建对象*/class Single{private static SingleSecond s=new Single();private Single(){}public static Single getInstance(){return s;}}//对象是方法被调用时,才初始化,也叫做对象的延时加载,称为 : 懒汉式//Single类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象class SingleSecond{private static Single s = null;private Single(){}public static Single getInstance(){if(s==null){synchronized(SingleSecon.class){if(s==null)s=new Single();}}return s;}}class SingleDemo{public static void main(String[] args){System.out.println("Hello World");}}
2 ) . 懒汉式与饿汉式的区别 :
2.1 对象是在方法被调用时才初始化,也叫做对象的延时加载,称为 : 懒汉式
Single类进内存,对象还没有存在,只有调用了getInstance方法时,才建立对象
2.2 对象在Single类进内存后就已经被创建初始化完毕,称为 : 饿汉式
小结 :
1. 工作常用饿汉式,因为安全,因为采用单例就是为了获取唯一对象,而懒汉则一开始需要判断是否为空才创建对象; 懒汉式的劣势在于 需要双重判断+锁机制 保证其安全性, 加剧了代码量
2.因此 ,定义单例,建议使用 饿汉式 (代码简洁版本)
二十 三. 面向对象(继承-概述1,2)
1 ) . 继承主要目录内容
[1] 继承的概述(本篇)
[2] 继承的特点
[3]super关键字
[4] 函数覆盖
[5] 子类的实例化过程
[6] final关键字
2 ) . Demo :
/*将学生和工人的共性描述抽取出来,单独进行描述只要让学生和工人与单独描述的这个类有关系,就可以了
继承:1.提高了代码的复用性2.让类与类之间产生关系,有了关系,才有了多态的特性
注意: 千万不要为了获取其他类的功能,简化代码而继承必须是类与类之间有所属关系才可以继承,所属关系 is a*/class Person{String name;int age;}class Student extends Person{void study(){System.out.println("good study");}}class Worker extends Person{void work(){System.out.println("good work");}}class Text{public static void main(String[] args){System.out.println("Hello world");}}
3 ) .核心记录 : 关于单继承与多继承与多层继承
3.1 java语言中 : java只支持单继承,不支持多继承
[1] 单继承 --> 指(一个子类仅支持继承一个父类)
[2] 多继承--> 指(一个类支持继承多个父类)
[3] 为何不支持多继承--> 因为存在安全隐患 : 当多个父类中定义了相同功能,而功能内容不同,子类都继承后,在调用时会不确定运行哪一个
3.2 java支持多层继承,也就是一个继承体系 -->A继承B ,B继承C,C继承D ....
[1] 如何使用一个继承体系中的功能呢?
第一步 : 欲使用此体系,先查阅此体系的父类描述 --> 因父类描述是该体系中的共性功能(基础功能)
[2] 在具体调用时,要创建继承体系中最子类的对象,为什么?
第一 ,因为有可能父类不可以创建对象
第二,要创建子类对象可以使用更多的功能,同时父类中的也包含了
一句话总结 : 查阅父类功能,创建子类对象,而后使用功能
小结 :
1. 类本身就是对象的抽象,抽的是对象的共性2. 父类-->超类-->基类-->父类的由来是由子类不断地向上抽取而来的
3 .类与类之间有间接继承关系(指具有个别共性)时,向上抽取出父类;类与类之间有直接继承关系(指具有全部共性)时,直接完成继承
4 .在继承中,最共性的父类类就是继承体系中最基础的功能
扫一扫
896
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
