Java小白修炼手册---锻体期-面向对象OOP(文档版)

目录

Java 面向对象编程(OOP)

day01--什么是类? 什么是对象?  如何创建类 ? 如何创建对象? 如何访问成员?

day02--方法的重载 (over load) :  构造方法 :     this :的用法    内存管理 :JVM来管理

day03-- null   表示空 ,没有指向任何对象       2.引用类型数组    3. 继承     4. super

day04 --1.引用类型变量之间画等号   2.基本类型变量之间画等号  二 .向上造型

day05-- 方法的重写 ,  重写与重载的区别 , package 和import 4.访问控制符 5.final

day06-- static 静态    static final 常量    抽象方法     抽象类

day07--成员内部类 ---如何画对象四个步骤

day08--匿名内部类

day09-- 接口

day10--  多态:意为表达多种形态效果

内存管理: 由JVM来管理

面向对象的三大特征:------------常见面试题

封装:

继承:

多态:

---

 

Java 面向对象编程(OOP)

 

• 面向对象讲编程的思想
  • 面向对象简称OO
  • 面向对象分析OOA
  • 面向对象设计OOD
  • 面向对象的编程OOP--从事
• 设计规则
  • 将派生类所共有的属性方法抽取到超类中---抽共性
  • 派生类行为一致,普通方法..行为不一致 ,抽象方法
  • 将部分派生类共有哦行为抽取到接口中,设计接口的目的是为了多继承

• day01--什么是类? 什么是对象?  如何创建类 ? 如何创建对象? 如何访问成员?

  • 什么是类? 什么是对象?
    • 对象:软件中真实存在的单个的个体/东西
    • 类: 类型/类别 代表一个类体
      • 类中 包含两种东西

1)对象所共有的属性/数据/特征------成员变量

2)对象所共有的行为/动作-------方法

• • • • 类可以设计出创建出多个对象   对象结构相同 数据不同
      • 类 是自己设计出来的一种数据类型---- 引用类型    class 类名{ }     借助new 关键字赋值
      •  类名 a = new 类名(); 对象调用时候a.
      •   创建对象  访问类中的东西 用 a.(a点 相当于 a的)
    • 类是对象的模板  对象是类的具体实例
  • 基于对象 抽出了类  类 是自己设计出来的一种数据类型---- 引用类型
  • 如何创建类 ? 如何创建对象? 如何访问成员?
    • 1)创建类 :  class Student(){}//类名 首字母大写
    • 2)创建对象: Student cyh = new Student();
    • 3)访问成员: cyh.成员变量;

cyh.方法();

• • • 关键字 null 默认值 空 零;
      •  1)创建一个学生对象;
      • 2)给所有成员变量赋默认值  不赋值则赋默认值 null

简称引用 

 数据类型      引用类型变量    指向           对象

Student              cyh            =          new Student();

• day02--方法的重载 (over load) :  构造方法 :     this :的用法    内存管理 :JVM来管理

• 方法的签名= 方法名 + 参数列表      

只要想访问类中的东西 必须先要创建一个对象  new 一个对象

• • 方法的重载 (over load) :
    •    定义: 1) 写在同一个类中 ( class 类名(){})方法名相同,参数列表不相同 ,方法体不同
    •  2)编译器在编译时会根据方法签名自动绑定调用方法
    • Aoo a =new Aoo();
    •  o.show();无参时自动调
    • o.show(int age);有参时自动调
  • 构造方法 :
    •  定义 :

1) 作用 给成员变量初赋值

2)必须与 类名 相同; 没有返回值类型,连void 都没有

3)创建对象时被自动调用

4)若自己没有定义构造方法,则编译器默认提供一个无参构造方法若定义了 ,则不会再默认提供

 5)构造方法可以重载

• • this :的用法
    •  1) 代词  指代当前对象,那个对象调用方法就指的那个对象
    •  2)只能用在方法中 ,方法中访问成员变量之前默认有一个 this. (this点)
    •  Java 规定 成员变量和局部变量可以同名
    • 成员变量 写在类中
    •  局部变量在构造方法中
    • class 类名(){//类
    •  int age;    //成员变量 在整个类中都可以以使用
    •  String name;//成员变量

//构造方法

• • •   类名(int age,  String name ){/局部变量  只作用于方法中  看最近大括号 作用域
    • 用法
    •  3.1)成员变量 与局部变量同名时---若想访问成员变量,则this.不能省略
    •                this.成员变量 = 局部变量;
    •                this.age = age;
    •                this.name= name;
    •  3.2)this.方法名();-----调用方法 (一般不写this.)
    •  3.3)this()----调用构造方法 后期讲
  • 内存管理 :JVM来管理
    • 1)main 方法中 创建 类型 基本类型变量    引用类型变量
    • 2)堆 :存储 new 出来对象 (包括成员变量,数组也是对象,,因为也是new 出来的 )
    •  3)栈 : 存储局部变量--写在方法中  (包括方法的参数)  基本类型变量
    •  4)方法区 : .class 字节码文件 (包括方法)

• day03-- null   表示空 ,没有指向任何对象       2.引用类型数组    3. 继承     4. super

  • null   表示空 ,没有指向任何对象
    • 若引用的值为null ,则该引用 不能再进行任何操作了
    • 若操作  则发生 NullPointerException 空指针异常
    •  异常运行时发生 ,编译不会报错
  • 2.引用类型数组   :
    •  创建一个Student型数组 包含3个元素 都是Student 引用型数组类型 默认值为null
    •   1) Student[ ] stus = new Student[3]; 创建一个Student数组对象
  • 分支主题
    • super  超级的意思  代词  代指当前对象的超类对象
      •  super.成员变量;  访问超类成员变量
      • super.方法名();----------访问超类方法
      •   super();----------访问超类构造方法
  • 继承   ------面向对象三大特征 封装 继承 多态
    • 1)有利于代码复用
    • 2)用 extends +类名 继承超类
    •  3)超类/父类 :具有派生类(子类)所共有的属性/数据/行为/动作(成员变量+方法)

派生类 /子类 :具有自己独有的属性/行为 (成员变量+方法)

• • • 4)派生类继承超类后  具有 :超类属性/行为 + 派生类的属性 行为
    •  5)继承具有传递性
    • 7)Java规定: 构造派生类之前必须先构造超类

7.1)在派生类的构造方法中,若自己没有调用超类的构造方法 ---则默认super()调用超类的无参构造法

7.2)在派生类的构造方法中,若自己调用了超类的构造方法,则不会再默认调用

• • •   super();调用 超类构造方法 必须放在派生类构造方法的第一行
  • 泛化----就是继承  将子类共有的属性 方法 抽取到父类中

•   day04 --1.引用类型变量之间画等号   2.基本类型变量之间画等号  二 .向上造型

• • 1.引用类型变量之间画等号
    • 1)指向同一个对象
    • 2)一个引用对数据进行修改 ,会影响到另一个引用对数据的使用;
  • 2.基本类型变量之间画等号
    • 1)赋值
    •  2)对一个变量的修改,不会影响另一个变量的使用

继承必须符合 ( is a)是一个的关系

• • 向上造型
    •  1)超类的引用可以指向一个派生类对象
    •  2)能点出来什么,要看引用的类型

•   day05-- 方法的重写 ,  重写与重载的区别 , package 和import 4.访问控制符 5.final

  • 方法的重写 (override):重新写 覆盖
    • 1)发生在父子类中,方法名相同,参数列表相同,方法体不同
    • 2) 重写方法被调用时,看对象的类型( new 谁就调谁)
    •  3)重写需要遵循"两同 二小 一大原则"---了解 一般都是 一模一样
    •  3.1)两同 :方法名相同 参数列表相同
    •  3.2)两小:
    • 1)派生类的返回值类型小于或等于超类方法的

1.1)void时  ,必须相同

1.2)基本类型时,必须相同

                 1.3)引用类型时,必须小于或等于

• • • 2)派生类方法抛出的异常小于或等于超类方法的
    • 3.3)一大: -> 派生类的访问权限大于或等于超类方法的
  • 重写 与重载的区别

重写: override

• • • 1)发生在父子类中,方法名相同,参数列表相同,方法体不同;
    •  2)遵循"运行期绑定",看对象的类型来调用方法

 

重载: over load

• • •  1)发生在一个类中,方法名相同,参数列表不同,方法体不同
    •  2)遵循"编译期绑定",看参数/引用类型来绑定方法

package 包 / import 导入

• package:

 1)作用:避免类的命名冲突

  2)包名可以有层次结构,  类的全称: 包名.类名

  3)同包中的类不能重名,不同包中的类可以重命名

4)建议:包名所有字母小写

建议/:域名反写.项目名称.模块名称.类名

• • • import :

        1)同包中的累可以直接访问

2)不同包中的类不可以直接访问,若想访问 两种方式

  2.1)先 import 声明类 再访问 类---建议 import +包名+类名

2.2)类的全称-----太繁琐 ,不建议

 

• 访问控制修饰符

数据(变量)私有化  

行为(方法)公开化 public

• • • 1)public-- 公有的---  -任何类
    •   2)protected--受保护的-- 本类 ,派生类,同包类
    • 3)默认的---- 什么也不写-- 本类 同包类
    • 4)私有的 --------------- 本类

  

• 说明:
• 1)类的访问权限只能是 public 和 默认的
• 2)访问成员变量的访问权限如上4种都可以
  • final
    • final :最终的 不可改变的 单独应用率低
    • 1)final  修饰的变量:  变量不能被改变
    •  2)final 修饰方法 :  方法 不能被重写
    •  3)修饰类 :类不能被继承

 

• day06-- static 静态    static final 常量    抽象方法     抽象类

  • 成员变量:实例变量 和静态变量
    •  实例变量: 没有static修饰，属于对象的，存储在堆中，有几个对象就有几份，通过对象点来访问
    •  静态变量: 有static修饰，属于类的，存储在方法区中，只有一份，通过类名点来访问
    •  堆: new出来的对象(包括实例变量)
    •  栈: 局部变量
    •  方法区: .class字节码文件(包括方法、静态变量)
  • static 静态
    • 1.静态变量:
      •    1.1)由static 修饰
      •    1.2)属于类 存储在方法区只有一份
      •    1.3)常常通过类名.访问
      •    1.4)何时用: 所有对象所共享的数据(图片,音频,视频等)
    • 2.静态方法:
    •  2.1)用static 修饰;
    •  2.2)属于类 存储在方法区中 ,只有一份
    •  2.3)通常通过类名来访问
    •  2.4)静态方法中没有this传递,所以静态方法 不能直接访问实例变量
    •  2.5) 何时用: 方法的操作和对象无关时
    • 3.静态块
    •  3.1)用 static 来修饰
    • 3.2)在类被加载期间自动执行,应为类只被加载一次,所以静态块只执行一次.
    •   3.3)何时用: 初始化/加载静态资源(图片,视频 ,音频等
  • 三 抽象方法
    •  1)用 abstract 修饰
    • 2)只有定义方法,没有具体实现(连大括号都没有)
  • 抽象类
    •  1)由 abstract修饰
    •  2) 包含抽象方法的类必须是抽象类
    •  3) 抽象类不能被实例化
    •  4)抽象类是需要被继承的,派生类;
    •  4.1)重写所有的抽象方法----变不完整为完整
    • 4.2)把派生类也声明为抽象类----不常用
    • 5)抽象类的意义

5.1)封装派生类所共有的属性和行为----代码复用

  5.2)为所有的派生类提供统一的类型---向上造型

   5.3)可以包含抽象方法,为所有派生类提供一个统一的入口(能点出来) 派生类的      具体实现不同,但入口是一致的

• • static final 常量:应用率高
    •  1)必须声明同时初始化
    •   2)建议:常量名所有字母大写,多个单词之间用下划线_ 隔开
    •  3)通过类名点访问,不能被改变
    • 4)编译器在编译时会将常量直接替换为具体的值效率高
    • 5)何时用: 数据永远不变,经常使用
    •   倘若要在类中修改原始的值,只用修改一次,使用方便

package OO.day06;
//static final 常量的演示
public class StaticFinalDemo {

	public static void main(String[] args) {
		
		System.out.println(Doo.PI);//通过类名点利来访问
		//Doo.PI=3.1415926;//**编译错误  常量不能被改写 改变
		
		//1)加载 Eoo.class到方法区
		//2)静态变量num 一并存储到方法区中
		//3)到方法区中获取num的值
		System.out.println(Eoo.num);
		
		//编译器在编译时会将常量直接替换为具体的值,效率高
		//相当于System.out.println(10);
		System.out.println(Eoo.SUM);
	}

}
class Eoo{
	public static int num=5;//静态变量
	public static final int SUM=10;//常量
}

class Doo{
	public static final  double PI= 3.14159;
	//public static final int NUM;//**编译错误 常量声明必须同时初始化
}

 

• 疑问
  • 问: 派生类既然还是需要重写的，那还要抽象方法step()干什么?
  •  答: 当向上造型的时候，通过超类的引用能点出来---------但是最终调用的还是派生类重写之后的

 

 

• • • 问: 不设计成抽象方法，就设计为普通方法，为什么不可以?
    •   答: 若把step()设计为普通方法，则派生类中可以重写也可以不重写，这样就达不到统一的效果的,很多时候做抽象方法是目的就是为了加限制、做统一

 

• day07--成员内部类 ---如何画对象四个步骤

  • 类中套类:外面称为外部类(outer),里面称为内部类(Inner)
  • 内部类通常只服务于外部类,对外不具备可见性
  • 内部类对象通常是在外部类中创建
  • 内部类中可以直接访问外部类成员,包括私有的,在内部类中有个隐式的引用,指向了创建它的外部类对象

 

• day08--匿名内部类

  • 1)若想创建一个  类(派生类) 的对象,并且对象只被创建一次,此时该类不必命名,称为匿名内部类-------优点:代码结构简洁
  • 常见面试题
    • 问:  内部类有独立的 . class 文件吗? 答:有

 

• day09-- 接口

  • 接口也是一种数据类型, 引用类型
  • 由 interface 定义
  • 只能包含常量,和抽象方法
  • 接口不能被实例化
  • 接口需要被  实现/继承  实现/派生类 必须重写抽象方法
  • 一个类可以实现多个接口,用逗号隔开, 用implements 来实现  implements作用与extends 相似   若该类既继承又实现  必须先继承后实现
  • 接口可以继承接口 ,继承多个接口 用逗号隔开
  • 接口是对继承单根型的扩展,实现多继承

• day10--  多态:意为表达多种形态效果

  • 意义
    • 同一类型的引用,在指向不同的对象时,有不同的实现,,行为的多态,方法
    • 同一个对象,被造型为不同的对象时,有不同的功能
  • 向上造型
    • 超类的引用指向派生类的引用
    • 能造型出的数据类型,有 超类+实现的接口
    • 能点出来什么 ,看引用的类型
  • 强制转换类型  规则,成功条件
    • 引用指向的对象,就是该类型
    • 引用所指向的对象,实现了该接口或继承了该类
  • 强转时若不符合上面的条件,,则会发生------------类型转换异常 Class Cast Exception
  • 建议
    • 强转之前 先通过 instanceof 来判断引用的对象是否异常
    • if(  引用  instanceof  强转的类型(超类/接口))

 

内存管理: 由JVM来管理

1.堆:

  1.1)存储所有new出来的对象(包括实例变量)

  1.2)垃圾:没有任何应用所指向的对象

垃圾回收器(GC) 不定时到内存中去清扫垃圾,回收过程是透明化的(看不到的),不一定一发现垃圾就立刻回收, 通过调用System.gc()可以建议虚拟机尽快调度GC来回收

1.3) 内存泄漏: 不再使用的内存没有被及时的回收, 严重的泄漏会导致系统的崩溃

建议: 不再使用的对象及时将引用设置为null

1.4) 实例变量的生命周期:

创建对象时存在堆中, 对象被回收时一并被回收

2. 栈:

2.1) 存储正在调用的方法中的局部变量(包括方法的参数)

2.2) 调用方法时会在栈中为该方法分配一块对应的栈帧,

栈帧中存储方法中的局部变量(包括方法的参数),

方法调用结束时, 栈帧被清除, 局部变量(包括参数)一并被清除

2.3) 局部变量的生命周期:

调用方法时存储在栈中, 方法调用结束时与栈帧一并被清除

3.方法区:

3.1) 存储.class字节码文件(包括方法, 静态变量)

3.2) 方法只有一份, 通过 this来区分具体的对象

面向对象的三大特征:------------常见面试题

封装:

1) 类: 封装的是对象的属性和行为

2) 方法: 封装一段特定的业务逻辑功能实现

3) 访问控制修饰符: 封装具体的访问权限

继承:

1) 作用: 代码复用

2) 超类: 所有派生类所共有的属性和行为

接口: 部分派生类所共有的属性和行为

派生类: 派生类所特有的属性和行为

3) 单一继承,多接口实现, 传递性

多态:

1) 行为的多态: 所有抽象方法都是多态的

对象的多态: 所有对象都是多态的

2) 向上造型, 强制类型转换, instanceof判断

3) 多态的表现形式: 重写