目录

Java 面向对象编程(OOP)

day01–什么是类什么是对象 如何创建类 如何创建对象如何访问成员/p>

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–什么是类什么是对象 如何创建类 如何创建对象如何访问成员/strong>

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

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

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

• • • • 类可以设计出创建出多个对象   对象结构相同 数据不同
      • 类 是自己设计出来的一种数据类型—- 引用类型    class 类名{ }     借助new 关键字赋值
      •  类名 a = new 类名(); 对象调用时候a.
      •   创建对象  访问类中的东西 用 a.(a点 相当于 a的)
    • 类是对象的模板  对象是类的具体实例
  • 基于对象 抽出了类  类 是自己设计出来的一种数据类型—- 引用类型
  • 如何创建类 如何创建对象如何访问成员/span>
    • 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)何时用: 数据永远不变,经常使用
    •   倘若要在类中修改原始的值,只用修改一次,使用方便

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

• • • 声明：本站部分文章及图片源自用户投稿，如本站任何资料有侵权请您尽早请联系jinwei@zod.com.cn进行处理,非常感谢！