javaSE--七、类与对象

一、类和对象的基本概念

1. 什么是类    类是一组具有相同特征 相似行为的对象集合
2. 什么是对象  万物皆对象
3. 类和对象的关系如何  在现实世界中 先有对象 抽离产生类
4. --------------------------------------------------------
5. 什么是类   类是模板
6. 什么是对象  对象是根据模板产生的实例
7. 类和对象的关系如何  在程序中 先定义类  后实例化生成对象

---

二、类和对象中的 属性(特征)  方法(行为)

1. 属性的本质 就是一个变量
2. 方法 是一个逻辑代码块
   1. 访问修饰符   public  公共的  所有的其他类均可访问该方法
   2. 返回值类型    void   没有返回值
   3. 方法名称   自己取名  遵从变量命名规则 规范
   4. 参数列表   ()
   5. 方法的主体  {逻辑代码}
3. 模拟一个猫类的创建过程
   1. 品种 年龄  颜色  特征
   2. 跑 叫 行为
4. 带参 和 带返回值的方法使用
   1. 访问修饰符  public 公共
   2. 返回值类型  
      1. 无返回值   void   方法中要么不出现return 要么return 单独出现
      2. 有返回值  标识具体的要返回数据的数据类型  方法体中必须保证百分之百进行对应数据类型数据的返回
         1. 优点：带有返回值的方法  具有更高的结果处理的灵活度
   3. 方法名称
   4. 参数列表{三要求：数量相同、类型相同、顺序相同}
   5. 方法主体

---

三、类图

1. 类的成员  属性 方法
2. 用于描述类的组成结构 和 类之间的关系

---

四、哪些类型可以作为参数 和 返回值

1. 系统提供的基础数据类型   int  double 等等
2. 系统定义的类
3. 自定义的类     类型 变量名;
4. 数据类型
   1. 值类型    byte  short  int  long  float  double  char  boolean  enum
      1. 值类型数据作为参数传递时 传递的是值 在方法内所做的所有修改不影响原变量值
   2. 引用类型  数组 String  系统定义的类  自定义的类
      1. 引用类型数据作为参数传递时 传递的是地址 所以在方法内进行的任意修改都会影响原数据
      2. 字符串虽然是引用类型 但由于字符串池具有不可更改性 所以字符串作为参数传递时 更多表现出值传递特征

---

五、方法重载

1. 在一个类中 允许存在多个同名方法 提高方法定义和调用的效率
2. 概念:  在一个类中 有两个或多个方法 它们的方法名称相同 参数列表不同 形成方法重载   所谓参数列表不同是指参数的数量、类型、顺序不同
3. 方法的重写
   1. 概念  在形成继承关系的父子类间 双方拥有同方法名 同参数列表 同返回值类型的方法 从而子类方法将完全覆盖父类方法的过程称为 重写

---

六、构造方法/构造体 构造函数

1. 概念  方法名与类名相同 不带返回值类型的方法 被称为该类的构造方法
2. 在定义类的过程中 如果没有显式的提供构造  那么系统会赠送一个无参 无逻辑代码的构造方法  只要提供的一个显式的构造方法  系统将不再赠送

---

七、封装

 

1）面向对象三大特征

• 封装（根据职责将属性和方法封装到一个抽象的类中）
• 继承（一个类 继承自 另一个类 从而获取被继承类所有属性 和 除构造方法外所有方法的过程——实现代码的重用，相同的代码不需要重复的写）   
• 多态（一个方法的多种不同的实现方式）//   (以封装和继承为前提)，不同的子类对象调用相同的方法，产生不同的执行结果

2）封装概念

• 根据职责将属性和方法封装到一个抽象的类中。隐藏具体的实现，提供一个对外的get和set方法给用户调用

---

八、继承

1. 为什么使用继承
   1. 为了抽离多个类中相同的属性和相似的行为
   2. 概念:  一个类 继承自 另一个类 从而获取被继承类所有属性 和 除构造方法外所有方法的过程
   3. 被继承的类  父类  基类
   4. 继承自它类的类  子类  派生类
   5. 父类构造后调用 先执行  子类构造 先调用 后执行
2. 继承的特性  --> 优点
   1. 继承具有单根性   一个子类只能继承自一个父类  一个父类可以被多个子类继承
   2. 继承具有传递性   
      1. 私有成员能否被子类继承    可以继承 但不能访问
   3. 降低代码的冗余
   4. 模拟现实世界 提高程序的可扩展性
3. 形成继承关系的父子类 应用技巧
   1. 对象实例化过程    父类类型 变量= new  子类类型();
      1. 该过程是一个类型泛化的过程  此时的对象无法访问子类特有的属性和方法
      2. 可以将父类类型作为方法的参数或返回值 以提高复用性
      3. 保证复用性的情况下 体现子类特征
         1. 类型推断和类型转换
            1. 类型推断    对象 instanceof  类型   用于推断对象是否属于该类型 如果属于 返回true 否则 返回false
            2. 类型转换   ((目标类型)对象).属性/方法
         2. 方法的重写
            1. 概念  在形成继承关系的父子类间 双方拥有同方法名 同参数列表 同返回值类型的方法 从而子类方法将完全覆盖父类方法的过程称为 重写

---

九、常用修饰符

1. 访问修饰符  用于修饰类 与 类中的成员
   1. public  公共的  最高的访问级别 最低的安全级别 代表所有其他类都可以访问
   2. protected  受保护的  被修饰的成员 在本包 或 本类的子类 中可访问
   3. (default)  缺省访问修饰符 不能明确的声明 代表 被修饰的类 或 类的成员只在本包中其他的类进行访问
   4. private 私有的  不能修饰类  可以修饰类的成员  被修饰的成员只能在本类中被访问

修饰符	本类	本包	子类	所有类
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

类的访问级别不得低于 类成员的访问级别

1. 静态修饰符 static
   1. 静态成员  依附于类
      1. 可以通过 类名.XX 进行访问  也可以实例化对象后 通过 对象.XX  进行访问
      2. 具有唯一性
   2. 实例成员  依附于对象
      1. 必须先生成对象 再用对象名.XX 进行访问
      2. 实例成员每个对象独享一份 伴随着对象生成 有无数多分
2. 终态修饰符 final  修饰类和类的成员
   1. 修饰类  类 变成  终态类  无法被继承
   2. 修饰方法  方法将不能被重写 终态方法
   3. 修饰变量 称为常量 常量有且仅有一次赋值的机会 一般在声明之初进行赋值
3. 异常处理
   1. 警告  waning  不影响程序的编译和运行
   2. 错误  error  编译期 检测到的语法错误
   3. 异常  Exception  所有异常类型的父类   运行期
      1. 除数为0异常
      2. 下标越界异常
      3. 空指针异常
      4. 类型转换异常
      5. 输入类型不匹配异常
   4. 一旦发生异常 程序会崩溃  异常发生 做出处理 避免程序崩溃
      1. 抛异常   

public void show()throws 异常类型{

 

}

方法的调用者必须对抛出的异常进行处理 除非 继续抛异常

1. 异常的捕获和处理

try{

           //放置可能发生异常的代码

}catch(异常类型 变量名){

          //进行异常的处理

}finally{    //final关键字对比

          //无论是否发生异常都一定要执行的代码

}

其中 try一定要出现一次  catch 和 finally至少要出现一个  catch可以出现多次 子类异常在前 父类异常在后

 

异常类型的继承树

---

十、抽象与接口

 

1. 抽象的概念
   1. 抽象方法  没有方法体的方法被称为抽象方法 需要使用abstract关键字进行修饰    public abstract void showMenu();
   2. 抽象类   一个类 如果包含了一个 甚至更多的抽象方法 那么该类必须使用 abstract进行修饰 变成抽象类
   3. 为什么使用  在多个子类对同一方法实现各不相同时  很难选择将某个子类方法提取到父类中 父类就提供抽象方法申明 子类必须重写实现  除非子类也是一个抽象类
      1. 注意  抽象abstract 和 终态 final 不能同时作用于同一个类
2. 抽象类和 普通类  接口的对比
   1. 抽象类
      1. 不能实例化
      2. 成员: 普通方法  属性  抽象方法
   2. 普通类
      1. 可以实例化
      2. 成员：普通方法  属性
   3. 接口
      1. 不能实例化
      2. 成员:抽象方法  静态常量
3. 接口
   1. 声明接口  interface
   2. 实现接口  implements
   3. 一个类可以继承自一个父类(单根性) 同时实现多个接口
   4. 接口是一种能力说明 定制了一组规则 由实现类实现 除非实现类是一个抽象类
   5. 接口本身可以继承