七、面向对象
7.1 初始面向对象
面向对象编程（OOP）
面向对象编程的本质是以类的方式组织代码，以对象的组织（封装）数据。
对象是具体的事务；类是抽象的，是对对象的抽象。
先有类然后才有对象。
7.2 方法回顾和加深
修饰符 返回类型 方法名（参数列表）{
// 方法体
return 返回值;
}
异常抛出
方法的调用
静态方法 （方法加了static）
public static int[] fun(int a){
int[] b = new int[a];
return b;
}
非静态方法（没有加static）
public void fun(int[] a) {
a[0] = 3;
}
静态方法是和类一起加载的
形参和实参
public class Demo {
public static void main(String[] arg) {
// 实际参数和形式参数的类型要对应
int add = Demo.add(1,2);
System.out.println(add);
}
// 形参
public static int add(int a,int b) {
return a+b;
}
}
值传递和引用传递
引用传递：对象，本质还是值传递。
this关键字
使用new创建一个对象。
类和对象的创建
//学生类
public class Student {
// 属性
String name;
int age;
// 方法
public void study() {
System.out.println(name + "在学习");
}
}
// 一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
// 类：抽象的，实例化
// 类实例化后会返回一个自己的对象
// stu对象就是一个Student类的具体实例
Student stu = new Studetn();
}
}
使用new关键字创建对象时，默认会进行初始化以及对类中构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。
构造器的两个特点：
- 必须和类的名字相同
- 没有返回类型，不用写void0
//
public class Person {
String name;
// 实例化初始值 无参构造
class Persion() {
this.name = "小明 ";
}
// 有参构造 一旦定义了有参构造，无参就必须显示定义
class Person(String name) {
this.name = name;
}
}
默认会有一个无参构造。
作用
- new本质在调用构造方法
- 初始化对象的值
对象方法的调用：
对象名.方法名();
类：
静态的属性 属性
动态的行为 方法
7.3 对象的创建分析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Pdk6oMhM-1622858892661)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210604162130771.png)]
7.4 面向对象三大特性
- 封装
- 继承
- 多态
访问控制
| 修饰符 | 名称 | 访问范围 |
|---|---|---|
| public | 公共的 | 当前类、同一包内、子孙类（同一包）、子孙类（不同包）、其他包都访问 |
| protected | 受保护的 | 当前类、同一包内、子孙类（同一包）可以访问 |
| default(不用写出) | 默认的 | 当前类、同一包内、子孙类（同一包）可以访问 |
| private | 私有的 | 只有当前类可以访问 |
程序设计追求：高内聚，低耦合。
- 高内聚：类的内部数据操作细节由自己完成，不允许外部干涉；
- 低耦合：仅暴露少量的方法给外部使用。
封装（对数据的隐藏）
封装的好处
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护增强了
属性私有（private）：使用getXXX/setXXX 去访问或者修改。
继承
是类与类之间的一种关系。类与类之间的关系还有组合、依赖、聚合等。
有父类（超类）和子类（派生类）。
java只有单继承，没有多继承。
使用关键字extends
子类会继承父类的所有属性和方法
父类使用private修饰的属性和方法子类是无法继承的，但是可以调用。
super 可以调用父类的方法和属性。
this 是本类的。
super注意点：
- super 调用父类的构造方法，必须在构造方法的第一个
- super 必须只能出现在子类的方法或者构造方法中
- super 和 this 不同同时调用构造方法
this:
代表的对象不同：
this: 本身调用者这个对象
super: 代表父类对象的应用
提前
this ： 没有继承也可以使用
super : 只能在继承条件才可以使用
构造方法
this() ； 本类的构造
super() ； 父类的构造
重写：需要有继承关系，子类重写父类的方法！
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大但不能缩小：public>protected>default>private
- 抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException —> Exception(大)
方法，子类的方法和父类的方法必须一致；方法体不同。
子类重写父类的方法。
public class A {
private String name;
private String address;
public void address(String address) {
this.address = address;
}
}
public class B extends A {
public void address(String address) {
System.out.println("我的地址：");
}
}
多态
多态就是同一方法可以根据发送对象的不同而采用多种不同的行为方式。
父类的引用指向子类
多态注意事项：
- 多态是方法的多态，属性没有多态。
- 父类和子类，有联系 。 类型转换异常（ClassCastException）
- 存在条件：继承关系，方法需要重写，父类引用指向子类对象。
- static 方法，属于类，它不属于实例
- final常量；
- private方法
instanceof （类型转换 ） 引用类型，判断一个对象是什么类型。
总结：
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型
- 把父类转换为子类，向下转型（强制转换）
- 方便方法的调用，减少重复的代码
static 关键字
static方法可以调用static方法，非静态方法能调用静态方法，但静态方法不能调用非静态方法。
7.5 抽象类和接口
抽象类
使用abstract修饰的类
抽象类只有方法名字，没有方法的实现。
接口可以多继承
- 抽象类不能new，只能靠子类实现。
- 抽象类中可以写普通的方法。
- 抽象方法必须在抽象类中。
接口的定义与实现
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范
声明类的关键字是class,声明接口的关键字是interface,实现接口使用implements
实现类必须实现接口的所有方法。
接口中的所有定义的方法其实都是抽象的public abstract
作用:
- 约束
- 定义一些方法，让不同的人实现
- public abstract
- public abstract final
- 接口不能被实例化，接口中没有构造方法
- implements 可以实现多个接口
- 必须要重写接口中的方法
7.6 内部类及OOP实践
内部类就是在一个类的内部在定义一个类。
public class Outer {
private int id;
public void out() {
System.out.println("这是外部类的方法");
}
class Inner {
public void in(){
System.out.println("这是内部类的方法");
}
}
}
public class Outer{
// 局部内部类
public void method() {
class Inner{
public void in() {
}
}
}
}
public class Test {
public static void main(String[] args) {
// 没有名字初始化类,不用讲实例保存到变量中（匿名类）
new Apple().eat();
}
}
一个java类中可以有多个class类，但是只能有一个public class。
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
八、异常机制
异常（Exception）：是指程序运行中出现的不期而至的各种问题，比如：文件找不到，非法参数等。
检查性异常：程序员无法预见的（比如打开一个不存在文件时，一个异常就发生了等，这些异常在编译时不能被简单地忽略。）
运行时异常：运行时异常是程序员可以避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误（Error）：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。比如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。
在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception.
Exception分支中有一个重要的子类RuntimeException(运行时异常)
- ArrayIndexOutOfBoundsException(数组下标越界)
- NullPointerException(空指针异常)
- ArithmeticException(算术异常)
- MissingResourceException(丢失资源)
- ClassNotFoundException(找不到类异常)等，
这些异常是不检查异常，程序中国矿业选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，一般是可以避免的。
Error和Exception的区别：
Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常是，java虚拟机一般会选择终止线程；
Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
8.1 异常处理机制
抛出异常
捕获异常
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 0;
// 正常处理区域
try {
System.out.println(a%b);
} catch (ArithmeticException e) {
// 异常捕获区域
System.out.println("程序出错，变量b不能为0");
} finally { // 处理善后工作
System.out.println("结束");
}
}
}
运行效果
异常处理五个关键字
try、catch、finally、throw、throws
捕获多个异常：从小到大
主动的抛出异常：
- throw
- throws
public class Test {
public static void main(String[] args) {
int a = 10;
int b = 0;
System.out.println();
// 主动抛出异常；一般在方法中使用
if (b == 0){
throw new ArithmeticException("b变量不能为0");
}
}
}
效果
自定义异常
自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，可以分为下面4个步骤：
- 创建自定义异常类
- 在方法中通过throw关键字抛出异常对象
- 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
- 在出现异常方法的调用者中捕获并处理异常
// 自定义异常类
public class MyException extends Exception{
// 传递数字<10
private int tail;
public MyException(int a) {
this.tail = a;
}
@Override
public String toString() {
return "MyException {" +
+ tail +
"}";
}
}
public class TestMyException {
// 可能存在异常的方法
static void test(int a) throws MyException {
System.out.println("传递的参数为 " + a);
if( a< 10) {
throw new MyException(a); //抛出
}
System.out.println("ok");
}
public static void main(String[] args) {
try {
test(8);
} catch (MyException e) {
System.out.println("MyException==>" + e);
}
}
}
效果：
异常总结
- 异常处理时异常时，采用逻辑去合理规避同时辅助try—catch处理
- 在多重catch块后面，可以加一个catch（Exception）处理可能会被遗漏的异常
- 对于不确定的代码，也可以加上try—catch，处理潜在的异常
- 尽量去处理异常，切忌只是简单地调用prinStackTrace()去打印输出
- 具体如何处理异常，要根据实际情况而定
- 尽量添加finally语句块去释放占用的资源
扫一扫
7253
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
