面向对象
面相对象&＃xff08;oop&＃xff09;和面向过程&＃xff08;pop&＃xff09;通常一起说&＃xff0c;一个是更加关注过程&＃xff0c;事力亲为&＃xff0c;而面向对象更加注重结果&＃xff0c;所以说&＃xff0c;面向对象更加是一种思想&＃xff0c;它贯穿整个java&＃xff0c;以上帝视角来看整个功能需求&＃xff0c;简化开发过程&＃xff0c;对业务逻辑进行封装&＃xff0c;对javabean进行封装&＃xff0c;让程序之间解耦&＃xff0c;代码之间的调用。
面向对象三大特性&＃xff1a;封装&＃xff0c;继承&＃xff0c;多态
一.封装
封 装&＃xff08;包装零散数据为一个整体&＃xff1b; 权限控制&＃xff09;
作用&＃xff1a;包装零散的数据为一个不可分割整体&＃xff1b;保证数据的安全性&＃xff08;通过四种访问权限&＃xff09;
1.创建对象的过程&＃xff1a;
1、 创建 类 Goods
定义类的属性
1、 属性类型 2、 属性值&＃xff08;创建对象时候赋值&＃xff09;
2、创建对象
创建使用&＃xff1a; 类名 变量名 &＃61; new 类名 ();
特别注意&＃xff1a; 创建的时候&＃xff0c;一定使用一个相同类型的变量去接受
3、对象的使用 &＃xff08;具体对象 外星人 &＃xff0c;机械革命&＃xff09;
1、 创建好对象
2、 属性的赋值 变量名.属性名称 &＃xff08;对象.属性名&＃xff09;
特别注意&＃xff1a; 属性的赋值 &＃xff0c;数据类型一定要相匹配
类 与 对象区别
类是一个抽象概念 &＃xff0c;是对象的模板
对象 是一个具体概念&＃xff0c; 代表是一个具体的事物
类 : 都是 属性 &＃43; 方法
事物的成员分为两种&＃xff1a;成员属性和成员功能。
成员属性在代码中的体现就是成员变量
成员功能在代码中的体现就是成员方法
必须使用 new 关键字创建对象&＃xff0c;new 做三件事&＃xff1a;
①会在堆中为相应类型分配空间
②会调用相应的构造方法来初始化对象
③将在堆中开辟的空间的地址返回回来
1、栈区&＃xff08;stacksegment&＃xff09;—由编译器自动分配释放,存放局部变量(方法内部变量&＃43;形式参数)基本变量值和引用变量地址&＃xff0c;具体方法执行结束之后&＃xff0c;系统自动释放 JVM 内存资源
2、堆区&＃xff08;heapsegment&＃xff09;—存放 new 出来的东西&＃xff0c;jvm 不定时查看这个对象&＃xff0c;如果没有引用指向这个对象就回收
3、方法区—存放全局变量&＃xff0c;静态变量和字符串常量,程序中方法的二进制代码&＃xff0c;而且是多个对象共享一个代码空间区域
2.Static关键字
1、局部变量
生命周期&＃xff1a; 从定义开始 到 方法执行结束
2、全局 变量&＃xff08;属性&＃xff09;
1、 静态属性 【当修改静态属性 时&＃xff0c; 对所有对象可见】
2、 成员属性 【当修改成员 属性时候&＃xff0c; 只对象当前对象可见】
生命周期&＃xff1a;
1、 静态属性 &＃xff1a; 类加载的时候一直存在 &＃xff08;绑定类&＃xff09;
2、 成员属性&＃xff1a; 创建对象到对象被回收 &＃xff08;绑定对象&＃xff09;
全局 变量 在创建 未被定义&＃xff1f;
初始化的时候&＃xff0c; 提供一个默认值
默认值&＃xff1a; 引用类型 ---> null
数字型&＃xff1a;
1、整形 0
2、浮点型 0.0
char ---->""
布尔型-----> false
方法
1、静态方法
2、成员方法
方法的使用&＃xff1a;
1、静态方法 (绑定类) 类名.方法名 对象.方法名
2、成员方法(绑定对象) 对象.方法名
方法之间的调用
1、静态方法 ---调用---> 静态方法 可行
2、静态方法 &＃xff08;类&＃xff09; ---调用----> 成员方法 &＃xff08;对象&＃xff09; 不可行
解决方案&＃xff1a; 在静态方法中 创建对象&＃xff0c;然后使用对象调用
3、成员方法&＃xff08;对象&＃xff09; ---调用----> 静态方法 &＃xff08;类&＃xff09; 可行
4、 成员方法&＃xff08;对象&＃xff09; ---调用----> 成员方法&＃xff08;对象&＃xff09; 可行
静态内容是优先于对象存在&＃xff0c;只能访问静态&＃xff0c;不能使用 this/super。
静态修饰的内容存于静态区。
简单拓展&＃xff1a;
JVM 在创建对象&＃xff0c;都会默认给对象 检测器
调用 方法区中两种方法时候&＃xff0c;
调用成员方法 &＃xff0c; 编译后 调用成员方法 将会去检测 this(对象)
调用静态方法&＃xff0c; 编译后 将不会去检测 this(对象)
3.成员变量和局部变量区别&＃xff1a;
区别一&＃xff1a;定义的位置不同
定义在类中的变量是成员变量
定义在方法中或者{}语句里面的变量是局部变量
区别二&＃xff1a;在内存中的位置不同
成员变量存储在堆内存的对象中
局部变量存储在栈内存的方法中
区别三&＃xff1a;声明周期不同
成员变量随着对象的出现而出现在堆中&＃xff0c;随着对象的消失而从堆中消失
局部变量随着方法的运行而出现在栈中&＃xff0c;随着方法的弹栈而消失
区别四&＃xff1a;初始化不同
成员变量因为在堆内存中&＃xff0c;所有默认的初始化值
局部变量没有默认的初始化值&＃xff0c;必须手动的给其赋值才可以使用。
4.构造方法&＃xff1a;
构造方法和一般方法的区别&＃xff1a;
构造方法在对象创建时就执行了&＃xff0c;而且只执行一次。
一般方法是在对象创建后&＃xff0c;需要使用时才被对象调用&＃xff0c;并可以被多次调用。
构造方法的特点&＃xff1a;
1&＃xff09; 名称必须和类名一致&＃xff0c;与类名相同
2&＃xff09; 没有返回类型|void
3&＃xff09; 构造器可以存在 return&＃xff0c;return 有选择的跳出构造器
4&＃xff09; 不能随便调用&＃xff0c;和 new 在一起使用&＃xff0c;其他时候不能调用
作用&＃xff1a;
初始化对象信息&＃xff0c;不是用于创建对象的
空构造&＃xff1a;
没有参数的构造器、无参构造
1&＃xff09; 一个类中&＃xff0c;如果没有显示|手动 加入 任意构造器 javac 编译后 自动加入空构造
2&＃xff09; 一旦加入构造器&＃xff0c; javac 不会加入空构造器
5.关键字&＃xff1a;this&＃xff1a;
可以在成员变量名前面加上 this.来区别成员变量和局部变量
在类的方法定义中使用的 this 关键字代表使用该方法的对象的引用。
this 即”自己”&＃xff0c;代表对象本身&＃xff0c;谁调用代表谁。在成员方法中或构造器中隐式
的传递。作用如下:
1、this 在构造器中只能放在第一行
2、this.属性避免属性和形参、局部变量同名&＃xff0c;发生就近原则
3、this([实参列表]): 构造器的首行调用其他构造器。
4、this 可以看作是一个变量&＃xff0c;它的值是当前对象的引用。
5、this 不能出现在被 static 修饰的内容中
6、构造方法不能相互调用(即你调用我、我调用你),会报错,类似死循环
6.语句块&＃xff1a;block { }
1、静态块
写法&＃xff1a;
static {
}
位置&＃xff1a; 类中&＃xff0c;方法外
生命周期&＃xff1a;在类加载时候加载&＃xff0c;只加载一次。
2、构造块
写法&＃xff1a; {
}
位置&＃xff1a; 类中&＃xff0c;方法外
生命周期&＃xff1a;在调用构造器的时候&＃xff0c;加载并优先构造器执行。
3、普通块
写法&＃xff1a; 同构造块
位置&＃xff1a; 方法中
生命周期&＃xff1a;同方法的生命周期
特别注意&＃xff1a;变量的作用域
4、同步块
7.javabaen
java类的属性进行私有化&＃xff1a; 实现高内聚&＃xff0c;低耦合
一个类&＃xff1a;特殊的类&＃xff1a;本质&＃xff1a;存放数据[数据模型]&＃xff08;相互业务class&＃xff09;
提供一个方法去访问属性
书写&＃xff1a;
Getter(获取属性值) Setter 方法 &＃xff08;修改 属性值&＃xff09;
命名的时候特点注意&＃xff1a;
名称&＃xff1a;
例如&＃xff1a; age &＃xff1a; getAge setAge
注意&＃xff1a; Boolean 类型的属性
在生成 getter 方法 ------》 is&＃43;属性名称
判断两个字符串是否相等&＃xff1a;变量名.eaquals(变量名)
JAVABEAN: 数据传递使用 &＃xff08;数据模型&＃xff09; ---->
javabean { vo bo po (pojo) dto model}
一种类 &＃xff1a;属性私有 对外提供方法操作属性
单纯事物bean { 业务bean 感受&＃xff1a;UserLogin}
8.关键字.package
package[包的定义] import[包导入] ------》 研究Class存放位置
1、 package
1、类的管理 【分包管理】
1、分包管理&＃xff1a; 核心&＃xff1a; 便于系统中代码的分类管理
分包【分层】
场景&＃xff1a; 电商项目
1、 用户 2、商品 3、购物车 4、 订单 5、支付 -----> 交易主流程 2、package 在类中使用
1、 在页面第一行 写法&＃xff1a; package 报名 ----》 表示当前类所在的位置 2、类重命名问题
在不同包下 可以创建相同名称的类
9.关键字.import
import &＃xff1a; 指明 引用Class 所在的位置
1、import : 指明class 书写的位置 &＃xff1a; 类体外 与 package 之间
2、 在变量上添包名
com.shsxt.demo.Person per &＃61; new com.shsxt.demo.Person("", 12);
不需要使用import的类有
1、 语言包 &＃xff08;java.lang&＃xff09;下的类
2、 同包下的类
特殊点 &＃xff1a; 导入静态属性 import static java.lang.Math.PI
10. 修饰符.\,访问权限&＃xff1a;
置于类的成员定义前&＃xff0c;用来限定其他对象对该类对象成员的访问权限。
通过访问权限的控制达到信息隐藏
通过访问权限 public&＃xff0c; protected &＃xff0c;default&＃xff08;默认&＃xff09;&＃xff0c; private 来封装类、方法及属性&＃xff0c;达到隐藏细节的目的
1: public: 一览无遗&＃xff1b; &＃xff08;同一个类&＃xff0c;同一个包&＃xff0c;子类&＃xff0c;所有类都可以访问&＃xff09;&＃xff1b;
2: protected:子承父业 (儿子自己使用)&＃xff1b; &＃xff08;同一个类&＃xff0c;同一个包&＃xff0c;子类可以访问&＃xff09;&＃xff1b;
3: default :家庭和睦&＃xff1b; &＃xff08;同一个类&＃xff0c;同一个包可以访问&＃xff09;&＃xff1b;
4: private :占为已有&＃xff08;同一个类可以访问&＃xff09;&＃xff1b;
包 同类 同包 子类 不同
public √ √ √ √
protected √ √ √ X
默认 √ √ X X
private √ X X X
方法的重写&＃xff1a; Java权限修饰符
子类在重写父类的方式时候&＃xff0c;重写的后的方法权限 >&＃61; 父类的权限
1、子类重写父里的public 方法&＃xff0c; 重写的方法的权限必须是public
2、父类中方法是 private权限 子类中不可重写也继承
二&＃xff1a;继承继承&＃xff08;类与类之间&＃xff09; ----> 父子类之间关系
继承使用一个关键字&＃xff1a; extends
继承&＃xff1a;子承父业
"父业" &＃xff1a; 父类 属性 和 方法
子类可以继承父类 “属性” 方法
待解决的问题&＃xff1f;
1、如果子类中出现于父类的中相同属性&＃xff1f;
1、单纯的继承关系
Dog dog &＃61; new Dog();
System.out.println(dog.name);
调用子类的属性值
2、“多态”现象 当出现 父引用指向子类对象
Animal a &＃61; new Dog(); -----> 向上转换 &＃xff08;自动转换&＃xff09;
System.out.println( a.name);
调用父类的属性 { 属性不多态 }
1.属性问题&＃xff1a;
1、 父 &＃xff1a;有 &＃43; 子&＃xff1a;有 -------》 { 1、单纯的继承关系 2、“多态”现象 }
2、父 &＃xff1a;有 &＃43; 子&＃xff1a; 没有 -------》 { 属性继承 }
3、父 &＃xff1a;没 &＃43; 子&＃xff1a; 有 -------》 {类的属性问题}
2、如果子类中出现于父类的中相同方法&＃xff1f;
子类继承父的方法&＃xff0c;但是有时候&＃xff0c;子类中修改父类的中继承过方法时候&＃xff0c;就会出现方法的重写
方法的重写&＃xff1f;Override
研究的范围&＃xff1f;{父子类关系&＃xff08;两个类&＃xff09;}
前置条件&＃xff1a;
1、父子类 包含相同的方法
1、方法用名 2、方法同参 3、 方法同返回值
检验&＃xff1a;在方法上添加一个注解 &＃64;Override
目的&＃xff1a; 覆盖 父类中的方法 提出先父子类继承方法的差异性
方法问题&＃xff1a;
1、 父 &＃xff1a;有 子&＃xff1a;有 ----> 重写
2、父 &＃xff1a;有 子&＃xff1a; 没有 ----》方法的继承
3、父 &＃xff1a;没 子&＃xff1a; 有 -----》 类的方法
2.JAVA中的继承模式&＃xff1a;
1、 单继承模式 如果想要继承多个类 ---> 使用多层继承&＃xff08;继承链&＃xff09;
好处&＃xff1a;
1、可复用代码
2、 继承关系对于父类没有影响&＃xff0c; 但是影响子类
3、 每一个子类都有一个直接父类 &＃xff0c;多个父类
3.构造器的问题&＃xff1a;
继承的构造器问题&＃xff1f;
当创建子类对象时候&＃xff0c; 先创建 父类对象{ 先执行父类构造器 在执行子类构造器 }
在子类对象创建的时候&＃xff0c; 我们子类 构造器中&＃xff0c;默认在第一行添加一个super()----> 父类空构造;
public Dog() {
super(); // this ()
// TODO Auto-generated constructor stub
}
1、子类构造器中隐含 super();
2、super的使用
3、子类构造器中出现相互调用的时候&＃xff0c; [ super 与 this ]
4.关键词super的使用
super的使用方式与this一样的。
区别&＃xff1a; this指代当前对象 super指向 父类对象
注意&＃xff1a;super 在子类成员方法方式
5.final&＃xff08;最终的&＃xff09;
变量&＃xff1a;常量&＃xff0c;变量将不能进行第二次赋值
方法&＃xff1a; 不能重写
类&＃xff1a;不能继承
6&＃xff1a;Object
一切类的最终父类
1、boolean equals(Object obj)
指示其他某个对象是否与此对象“相等”。
2、 int hashCode()
返回该对象的哈希码值。
对象地址值
3、 String toString()
回该对象的字符串表示。
注意&＃xff1a;
Object obj &＃61; new Goods("");
Object类型 可以接受任何 类型的对象 { 适合的类型的 接受 }
三&＃xff1a;多态
在编译时&＃xff0c;不能确定方法调用者&＃xff0c;只有在运行的时候&＃xff0c;才能确定
多态&＃xff08;类与类之间&＃xff0c; 类与接口之间 &＃xff09;
1&＃xff1a;当出现父类引用指向子类对象&＃xff0c;发生多态&＃xff1b;
2&＃xff1a;属性不会发生多态&＃xff1b;
3&＃xff1a;方法会发生多态&＃xff08;编译看类型&＃xff0c;运行看对象&＃xff09;
多态 发生的场景&＃xff1a;
两个视角 【继承 和 实现】
1、继承视角 看待多态 【父 子 类关系 】
1、 类继承
1、定义 class 动物类 Animal
2、 定义class 哈士奇&＃xff08;Hsq2&＃xff09; &＃xff08;继承 动物类 &＃xff09;
Animal 2ha &＃61; new Hsq2() ;
属性问题&＃xff1a;
属性不发生多态现象&＃xff1a; 此时调用的属性一定父的属性
方法问题&＃xff1a;
方法发生多态
2、抽象类继承 com.shsxt.person
属性问题&＃xff1a;
属性不发生多态现象&＃xff1a; 此时调用的属性一定父的属性
方法问题&＃xff1a;
方法发生多态
2、实现 视角 看待多态 【 实现关系 】
1、接口实现
1、定义一个
public interface Employee {
public void work ();
}
2、定义实现子类
public class CodeMonkey implements Employee {
&＃64;Override
public void work() {
System.out.println("码代码。。 修键盘 。。 贴膜 。。。 修鼠标&＃xff0c;&＃xff0c;&＃xff0c; 只有你想不到&＃xff0c;没有不会做。。");
}
public void makeMoney () {
System.out.println("挣钱。。。。");
}
}
使用的
Employee emp &＃61; new CodeMonkey();
emp.work();
&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;&＃61;
多态特性触发的前置条件&＃xff1a; 继承和实现
多态的弊端&＃xff1a;【模糊】
多态 &＃xff1a; 隐藏了子类中新增加的方法
类型转换
1)、upcasting 自动|向上
父类型 &＃61; 子对象;
2)、downcasting 强制|向下
子类型 &＃61; &＃xff08;子类型&＃xff09;父引用;
案例&＃xff1a;
Employee emp &＃61; new CodeMonkey();// 向上装换 自行
emp.work();
// emp.makeMoney();
CodeMonkey code &＃61; (CodeMonkey)emp; // 向下 强制装换 ----》 异常
code.makeMoney();
注意事项&＃xff1a;
4、instanceof&＃xff1a;
作用: 发生多态时&＃xff0c;为了避免转换错误
1&＃xff1a;抽象类
由abstract修饰的类 遵循常规类(属性和方法) ----》【特殊点&＃xff1a; 抽象方法】
抽象类与类区别&＃xff1a; 类定义{属性定义与{方法定义}}
抽象类既可以有抽象方法也可有普通方法
特别注意&＃xff1a;
1、抽象类只能定义&＃xff0c; 不能实例化。 但是有构造器 但是不能使用
2、 当子类中继承抽象类时候&＃xff0c;如果抽象父类中有抽象方法的&＃xff0c;子类必须重写
3、抽象方法不能定义为私有的
4&＃xff1a;不能使用 final 修饰符
定义&＃xff1a;
public abstract class Vehicle {
public String vname;
}
什么是抽象方法&＃xff1f;
定义遵循普通方法的定义&＃xff0c; 但是(在方法添加 abstract)而且 (没有方法体)
作用&＃xff1a; 定义方法的模板 &＃xff0c;但是方法的具体实现
/**
* 抽象方法
*/
public abstract void run();
如果抽象父类 包含 抽象方法 &＃xff0c;那继承的子类是否一定重写抽象方法&＃xff1f;
关键&＃xff1a; 1、看继承的子类是抽象类---->按需重写
2、看继承的子类是普通类----> 一定重写
包含抽象的方法的不一定是抽象类&＃xff1f; 也可有可能是一个接口
抽象类 {
1、抽象方法
2、普通方法
}
2&＃xff1a;接口
关键词&＃xff1a;interface
作用&＃xff1a; 完全规范 {功能类似于抽象类}
定义&＃xff1a;
public interface 接口名称 {
}
研究接口&＃xff1a;
1、属性
都是常量
2、方法 ----》 {都是抽象方法}
注意&＃xff1a; 定义的抽象方法 可以不加 abstract
---> 是否抽象方法都需要 abstract关键词
---> 定义的方法的权限是能是 public 或者是 默认的
接口的使用 【多实现】
1、 普通类 实现接口 implements
实现子类中必须重写 接口的方法
2、接口继承接口
使用的关键词 extends
子接口中 按需实现 父接口的方法
3&＃xff1a;适配器模式
适配器模式
重写&＃xff1a;
1、接口方法重写
劣势&＃xff1a; 需要重写所有的方法 优势&＃xff1a;多实现
2、继承方法重写
劣势&＃xff1a; 单继承 优势&＃xff1a;选择性重写
接口定义规范&＃xff1a;
所有的规范
中间适配器&＃xff1a;class
重写所有的接口方法
具体实现子类&＃xff1a;
按需要重写
4、 instanceof&＃xff1a;
对象名instanceof&＃xff08;类&＃xff09;
作用: 发生多态时&＃xff0c;为了避免转换错误
关系运算符:
1)、instanceof 用来判断一个引用指向的对象是否为一个类或其子类的实例。只适用在一条继承链上
如果不是返回 false,如果是返回 true.
2)、必须在继承链上&＃xff0c;发生多态时使用&＃xff0c;否则编译错误
京公网安备 11010802041100号