JAVA学习之路——面向对象

weixin_51846190

已于 2022-08-18 09:04:29 修改

阅读量64

点赞数 1

文章标签： java 学习

于 2022-08-17 17:37:01 首次发布

本文链接：https://blog.csdn.net/weixin_51846190/article/details/126245152

版权

什么是对象，对象的属性和方法

对象：用来描述客观事物的一个实体，由一组属性（静态特征）和方法（动态特征）构成。

属性：用来描述对象的固有特征，一般是名词；

方法：用来描述对象的动作，这个对象能干什么，一般是动词。

类和对象的关系

类是抽象的，对象是具体的
类是具有相同属性和行为（方法）的对象的集合
对象是类的一个实例，是一个具体的实体

使用对象

创建对象
- 类名对象名 = new 类名（）；
引用对象
- 对象名.属性
- 对象名.方法名（）

方法

方法定义类的某种行为（或功能），是功能的实现。

方法可以直接调用当前类的属性

方法的五要素：访问修饰符返回值类型方法名 (参数列表){方法体}
- 修饰符public：公共的，公开的，这个方法在哪里都能被调用
- 返回值类型：这个方法被调用了，有没有返回结果，void表示没有返回结果，如果有返回结果，void要改为返回值的具体类型，并在方法结尾使用return将结果返回。
- 方法名：见名思意，遵循标识符命名规则。
- 参数列表：调用这个方法需不需要有条件，如果需要条件，就在（）进行声明，方法和属性声明一样，此时的参数在方法中是一个占位符，形式参数，形参在方法中可以直接使用。
- 方法体：实现功能的具体代码。

方法的调用

对象名.方法名（）；

方法间可以互相调用：

//在同一类中方法a()调用方法b()直接调用
public void a(){

    b();//调用b()

}

//调用同一包下其他类中的方法，先实列化对象，在调用

public void a(){

    Dome t = new Dome();
    t.b()//调用Dome类中的b()方法

}

方法的参数

无参方法：参数列表中没有参数
带参方法：参数列表中带有参数

无参方法：
访问修饰符 返回类型 方法名（）{

方法体

}

public void show(){


}

带参方法：
访问修饰符 返回类型 方法名（<形式参数列表>）{

方法体

}

public void show(int a,int b){


}

//调用有参方法时，必须要传递对应类型的参数，否则报错。

构造方法

作用：创建对象，初始化对象

//学生类
public class Student {
	
	//属性
	String name;
	int age;
	String sex;

	//系统默认的无参构造方法，写和不写他都是存在的
	public Student() {
	}
	
	//有参构造方法,创建对象的时候就已经给了初始值了
	public Student(String name, int age, String sex) {
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
｝

构造方法和普通方法的区别：

构造方法访问修饰符一般是public, 一般方法根据实际情况选择修饰符
构造方法没有返回值类型，一般方法要么无返回值-void，要么有返回值
方法名与类同名，一般方法见名思意，遵循驼峰命名规则
构造方法的方法体是对象的初始化代码，一般方法是功能的实现
调用方式不一致，普通方法需要使用对象来调用，构造方法是new, this, super

方法重载

在同一个类中有一些方法的功能相同，仅仅是参数列表不一样，此时如果去定义不同的方法名很麻烦。

于是规定，方法名可以一样，但是参数列表必须不一样。所以就有了方法的重载。

方法重载的判断标准：同类同名不同参，与其他无关（不同参：不同的参数列表：个数不同，类型不同，顺序不同）

pbulic void a(){


}
pbulic void a(int a ,int b){

}

this关键字的用法

this. 代表当前对象，可以用来调用属性，可以调用方法，还可以用来调用构造方法

this.方法名()，调用方法

this()表示调用构造方法，括号中没有参数的花表示调用无参的，有参数的话，则调用有参的，

如果this来调用构造方法的话，必须要位于方法的第一行

成员变量与局部变量

成员变量：是属于类的变量，其实就是类中的属性，类中的每一个方法都可以共享；

局部变量：是定义在某个方法中的变量，只能在定义的方法中访问，其他的方法不能共享；

成员变量和局部变量的区别

定义位置不同
- 成员变量：定义在类中的变量，属于类
- 局部变量：定义在方法中的变量，属于方法
作用域不同
- 成员变量：属于类，类中的每个方法都可以使用
- 局部变量：属于方法，只能在某一个方法中使用
初始值不同
- 成员变量：有默认的初始值，在加载类的时候，就会给成员变量赋值（默认值）
- 局部变量：没有初始值，必须初始化之后才可以使用
生命周期不同
- 成员变量：属于类，随着对象的创建而创建，随着对象的消失而消失- 垃圾回收器
- 局部变量：属于方法，随着方法的调用而创建
优先级不同
- 在同一个类中，成员变量和局部变量同名是，局部变具有更高的优先级，在方法的参数列表中的参数，也是局部变量

封装

封装的概念

封装是Java的三大特性之一

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实习对隐藏信息的操作和访问

封装的原则
- 将属性隐藏起来 - 使用private关键字来修饰属性，私有的，私有化的，被private修饰的内容，只能在本类中使用，可以用来修饰属性和方法
- 对外提供公共的访问方法（赋值，取值），提供getter，setter方法来操作隐藏属性
实现封装的步骤
- 私有化属性；
- 创建公共的getter和setter方法；
- 在setter方法中添加控制语句

被private修饰的属性和方法只能在本类中访问，其他类不能直接访问。

封装的好处
- 隐藏了实现的细节，提高安全性
- 符合Java的“高内聚，低耦合”思想
- 提高了软件的独立性和可重用性

包

作用：

1、文档分门别类，易于查找和管理；
2、解决文件同名冲突问题；
3、有助于实施访问权限管理；
包：package，需要放在java源代码中的第一条语句；以分号结尾。类似于windows中的文件夹，

包的命名规则：

1、包名由小写字母组成，不能以圆点开头或结尾；
2、包名之前最好加上唯一的前缀，通常是组织倒置的域名；

包的创建方式：

分别创建包和类
创建类的同时创建包

包的导入：

如果需要使用其他包下面的类，可以使用import 关键字导入

导入规则：import 包名.类名

一个类同时引用了两个来自不同包的同名类，必须通过完整类名来区分
package和import的顺序是固定的

package必须位于第一行（忽略注释行）；

只允许有一个package语句；

其次是import；

接着是类的声明；

访问权限控制

ava 中一共有四种访问权限控制，其权限控制的大小情况是这样的：public > protected > default(包访问权限) > private

public：所修饰的类、变量、方法，在任何地方均具有访问权限；
protected：这种权限是为继承而设计的，protected所修饰的成员，对所有子类是可访问的，但只对同包的类是可访问的，对外包的非子类是不可以访问；
包访问权限（default）：只对同包的类具有访问的权限，外包的所有类都不能访问；
private：私有的权限，只对本类的方法可以使用；其他地方均不能访问

static修饰符

static表示“全局”或者“静态”的意思，用来修饰成员变量（属性）和成员方法（方法），也可以形成静态static代码块；每个静态代码块只会被执行一次。

静态代码块在对象创建之前执行，每创建一个对象都会执行一次构造方法。而每个静态代码块只会被执行一次。

static变量，静态变量

按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；

另一种是没有被static修饰的变量，叫实例变量。实例变量必须通过对象来调用。

静态变量特点：

1、被static修饰的变量静态变量，非静态变量叫实例变量

2、在内存中只有一个，在加载类的时候创建，被所有方法和对象共享

3、其他类中，可以直接通过类名访问（可以通过类名直接调用）

static方法，静态方法

静态方法就是被static修饰的方法，没有被static修饰的方法称为实例方法，实例方法必须要对象才可以调用，

静态方法可以直接通过类名调用，任何的实例也都可以调用

静态方法特点：

静态方法中不能使用this和super，this当前对象
2.不能直接访问所属类的实例变量和实例方法，
可直接访问类的静态变量和静态方法，静态能够调用静态资源，不能直接调用非静态资源
可直接通过类名.方法名访问
规定：静态只能调用静态，非静态只能调用非静态

静态变量和实例变量的比较：

初始化：

静态变量在创建对象之前会被加载

实例变量，随着对象的创建被创建

注意：在静态资源内部不能直接调用非静态的资源（属性和方法）

规定：静态调用静态，非静态调用非静态。

继承

将子类共有的属性和方法抽取到父类中,减少重复代码，实现代码的重用

使用继承extends

子类可以继承父类

子类可以继承父类中，被public和protected修饰的内容
如果父类和子类在同一个包下的化，默认修饰符修饰的内容也会被继承

子类不能继承那些内容

私有的方法
构造方法不能被继承
子类和父类不在同一个包下，默认修饰符修饰的内容

Java中的类，只能单继承，不能同时继承多个类，可以间接的继承，可以使用父类的父类中的方法

super关键字

调用父类的属性和方法，用法和this一样

super调用构造方法，必须在子类的构造方法中才能调用，必须位于第一行

方法的重写

使用场景：当父类中的方法不能满足子类的需求

重写的前提是：必须在继承体系下，也就是必须存在继承关系

方法重写的原则

1、方法名必须相同

2、参数列表必须相同

3、返回值类型相同或者是其子类

4、访问权限相同或不能严于父类

注意：

一般不会去改变返回值和访问权限
父类的私有方法不能被重写，重写的是可以被继承的方法
一般情况下，重写都是会存在一模一样的方法仅仅是方法体不一样。
只能重写继承来的方法

方法重写和重载的区别

重载：同类同名不同参，与其他无关（同一个类中，方法名，参数列表不同--个数不同，类型不同，顺序不同）

重写：在子类和父类中存在，同名同参同返回值同访问修饰符的方法（返回值可以是其子类，访问修饰符不能比父类更严格）

object介绍

Object类是所有类的父类；

多态

什么是多态

在java中多态的体现？ --- 》所谓多态，就是指一个引用变量在不同的情况下的多种表现状态。也可以理解为，多态是指通过指向父类的引用变量，来调用在不同子类中实现的方法。

2：多态的运用

一般用于继承体系下，子类重写父类的某个方法，调用时根据具体的子类实现去调用子类的方法

抽象类

什么是抽象方法：被abstract修饰的方法，就是抽象方法。
1. 抽象方法和普通方法的区别

1. 语法：抽象方法一定时被abstract修饰的方法，普通类一定不能被abstract修饰
2. 方法体：抽象方法没有方法体，普通方法一定有
3. 位置：抽象方法只能在抽象类中，普通方法随意可以在抽象类中也可以不在

2. 抽象类和抽象方法的关系

1. 抽象方法必须声明在抽象类中，但是抽象类中不一定有抽象方法
2. 如果一个类中存在抽象方法，那么这个类一定是抽象类
3. 弱国一个类是抽象类的话，不一定有抽象方法

3. 抽象类中能不能创建对象

不能。因为抽象类中可能有抽象方法，抽象方法没有方法体，调用抽象方法没有意义

4. 抽象类能不能有构造方法

有，任何一个构造方法，第一行都一个super(), 留给子类使用的

5. 普通类和抽象类的区别

1. 语法：抽象类一定被abstract修饰，普通类一定不能

2. 内容：抽象类中可以有抽象方法，普通类不能

3. 抽象类不能实例化，普通类可以实例化

6. 抽象类中是否存在静态方法？ - 静态方法是独立于对象的，需要实例化，抽象类中是可以存在的，也可以被调用

特征：

1：抽象方法没有方法体，只有方法的声明；

2：如果一个类中存在抽象方法，那么这个类必须声明为抽象类；abstact修饰的类,抽象类不能创建对象

3：抽象类不能被实例化；

4：抽象方法必须在子类中被重写，除非子类也是抽象类；
接口
##### 接口的特点

1、接口不能用于实例化对象。

2、接口没有构造方法。

3、接口中所有的方法必须是抽象方法。默认为：public abstract

4、接口不能包含成员变量，除了 public static final 常量。

5、接口不是被类继承了，而是要被类实现。实现使用关键字：implements

6、接口支持多实现。

7、一个类可以继承一个类的同时实现多个接口。

使用接口

使用接口的步骤：

1、创建接口，声明方法

2、创建类，实现接口，实现接口中的方法

3、使用实现后的方法执行具体的操作

接口与抽象类的区别

1、抽象类使用关键字abstract class修饰，接口使用关键字interface；

2、抽象类使用关键字extends实现继承，接口使用implements来实现

3、抽象类中可以包含抽象方法和普通方法，接口中只能有抽象方法（1.7）；

4、抽象类可以有构造方法，接口中不能有构造方法；

5、抽象类可以有成员变量，接口中只能有常量；

6、抽象类只能单继承，接口可以多继承；

7、抽象类里面的方法可以是public,protect,private，接口的方法只能是public；

异常

程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常

常见的异常有：

算术异常：ArithmeticExecption

空指针异常：NullPointerException

数组下标越界异常：ArrayIndexOutOfBoundsException

类型转换异常：ClassCastException

数组负下标异常：NegativeArrayException

字符串转换为数字异常：NumberFormatException

输入类型不匹配：inputMisMatchException

异常处理

异常发生时，是任程序自生自灭，立刻退出终止，还是输出错误给用户异常异常处理机制能让程序在异常发生时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。

在java应用中，异常的处理机制分为抛出异常和捕获异常。

捕获异常： try , catch ,

抛出异常：throw, throws

捕获异常

捕获异常：一旦方法抛出异常，系统自动根据该异常对象寻找合适异常处理器（Exception Handler）来处理该异常。所谓合适类型的异常处理器指的是异常对象类型和异常处理器类型一致。

try -catch 语句

try {
 //可能产生的异常的代码区，也称为监控区
//try块中放可能发生异常的代码。
//如果执行完try且不发生异常，则不会执行catch内的内容，跳过catch，继续向下执行
//如果发生异常，则尝试去匹配catch块。
      }catch (SQLException SQLexception) {
          //捕获并处理try抛出异常类型为SQLException的异常
 //每一个catch块用于捕获并处理一个特定的异常，或者这异常类型的子类。Java7中可以将多个异常声明在一个catch中。
 //catch后面的括号定义了异常类型和异常参数。如果异常与之匹配且是最先匹配到的，则虚拟机将使用这个catch块来处理异常,执行catch块里面的代码。
 //在catch块中可以使用这个块的异常参数来获取异常的相关信息。异常参数是这个catch块中的局部变量，其它块不能访问。
 //如果try中没有发生异常，则所有的catch块将被忽略。继续向下执行
//如果try有异常，当发生异常后，try中异常后面的代码不会被执行。
         //如果catch中的异常与之匹配，则会执行catch代码块，并且继续向下执行
        //如果catch中没有与报错信息匹配的异常，此时程序报错，程序停止
     }catch(Exception  e) {
          //捕获并处理try抛出异常类型为ExceptionType2的异常

try-catch代码块的执行顺序：

try没有异常时，try代码块中的语句依次被执行，跳过catch。执行后续代码。
try捕获到异常时，如果存在与之匹配的catch，则跳到该catch代码块执行处理；处理之后继续执行后续代码。注意，try代码块出现异常之后的代码不会被执行。
try捕获到异常时，如果没有与之匹配的catch子句，则该异常交给JVM处理；如果存在finally，则其中的代码仍然被执行，但是try块发生异常之后的代码和finally之后的代码不会被执行。

printStackTrace() 输出异常的堆栈信息 -- 在命令行打印异常信息在程序中出错的位置及原因

try-catch-finally 语句

try {
       //可能产生的异常的代码区
   }catch (ExceptionType1 e) {
       //捕获并处理try抛出异常类型为ExceptionType1的异常
   }catch (ExceptionType2 e){
       //捕获并处理try抛出异常类型为ExceptionType2的异常
   }finally{
 	 //finally块通常是可选的。
//无论异常是否发生，异常是否匹配被处理，finally都会执行。
//一个try至少要有一个catch块，否则， 至少要有1个finally块。但是finally不是用来处理异常的，finally不会捕获异常。
//finally主要做一些清理工作，如流的关闭，数据库连接的关闭等。 
   }

try-catch-finally代码块的执行顺序：

try没有捕获异常时，try代码块中的语句依次被执行，跳过catch。如果存在finally则先执行finally在执行后续代码，否则执行后续代码。
try捕获到异常时，如果存在匹配的catch，则跳到该catch代码块执行处理。如果存在finally则先执行finally代码块，然后执行后续代码；否则直接执行后续代码。另外注意，try代码块出现异常之后的代码不会被执行。
try捕获到异常时，如果没有匹配的catch，则该异常交给JVM处理。如果存在finally，则其中的代码仍然被执行，但是finally之后的代码不会被执行。

捕获总结

try代码块：用于捕获异常。其后可以接零个或者多个catch块。如果没有catch块，后必须跟finally块，来完成资源释放等操作；

catch代码块：用于捕获异常，并在处理异常。

finally代码块：无论是否捕获异常，finally代码总会被执行。如果try代码块或者catch代码块中有return语句时，finally代码块将在方法返回前被执行。

唯一一种finally不会被执行的情况就是，发送异常时，手动的退出了系统。

抛出异常

如果一个方法可能会出现异常，但没有能力处理这种异常，或者自己不想解决的话，可以使用甩锅的方式解决。

throws抛出异常

如果一个方法可能抛出异常，但是没有能力处理该异常或者需要通过该异常向上层汇报处理结果，可以在方法声明时使用throws来抛出异常。这就相当于计算机硬件发生损坏，但是计算机本身无法处理，就将该异常交给维修人员来处理。

Public  void  methodName() throws Exception1,Exception2….{
}

//其中Exception1,Exception2…为异常列表，一旦该方法中某行代码抛出异常，则该异常将由调用该方法的上层方法处理。如果上层方法无法处理，可以继续将该异常向上层抛。

throw抛出异常

在方法内，用throw来抛出一个Throwable类型的异常。一旦遇到到throw语句，后面的代码将不被执行。然后，便是进行异常处理——包含该异常的try-catch最终处理，也可以向上层抛出。注意我们只能抛出Throwable类和其子类的对象。

throw new ExceptionType;

//比如我们可以抛出：throw new Exception(); 当在方法内部抛出一个异常时，一般也会在方法上再次抛一个异常。

//也有时候我们也需要在catch中抛出异常,这也是允许的，比如说：

Try{

//可能会发生异常的代码

}catch(Exceptione){

   throw new Exception(e);

}

throw与throws

自定义异常

如果 Java 提供的内置异常类型不能满足程序设计的需求，可以设计自己的异常类型，自定义异常类必须继承现有的 Exception 类或 Exception 的子类来创建，其语法形式为

class  <自定义异常名>  extends  <Exception>
//在编码规范上，一般将自定义异常类的类名命名为 XXXException，其中 XXX 用来代表该异常的作用

自定义异常类一般包含两个构造方法：一个是无参的默认构造方法，另一个构造方法以字符串的形式接收一个异常消息，并将该消息传递给父类的构造方法。

自定义异常的具体步骤：

1：定义一个类继承Exception或者其子类；

2：编写构造方法（无参和有参）；

3：在需要的地方调用异常类（使用throw 抛出实例化后的异常）- 在方法的声明中需要声明

异常使用原则

从性能角度看：

1：不要将所有的代码都放在try中，try只放有可能发送异常的代码；

2：在catch中指定具体的异常类型。

记住：能解决的使用捕获，不能解决的使用抛出