1.5.1 面向对象

1.5.1.1 类与对象

​ 类是一个模板，它描述一类对象的行为和状态。定义类就是定义类的属性与行为（方法）。

1
2
3
4
[ 权限修饰符] [ 修饰符] class 类名{
    成员变量;
    类方法;
}
1
2
3
4
5
6
7
public class Employee{
    String employeeName;  //类的属性
    public void name(){
        System.out.println(employeeName)
    }
    
}

​ 对象是类的实例，定义对象和定义变量一样。

1
2
3
4
5
6
7
8
9
10
11
12
类名 对象名
在使用对象之前必须给他分配内存,必须通过new 关键字来实现
Empoyee =new Employee();


Student s  = new Student();
Student 是一个引用数据类型
s是一个变量名
new Student 是一个学生对象
读取数据：引用.变量名
s.name
修改数据：引用.变量名=值;

1.5.1.2 封装

 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

优点：

  • 良好的封装能够减少耦合。

  • 类内部的结构可以自由修改。

  • 可以对成员变量进行更精确的控制。

  • 隐藏信息，实现细节

  • 安全性高

  • 封装之后才可以成为对象，真正的独立体

  • 封装之后可以重复使用

    1
    2
    3
    4
    public class Person {
        private String name;
        private int age;
    }

1.5.1.3 继承

​ 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

  • 子类拥有父类非 private 的属性、方法。
  • 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
  • 子类可以用自己的方式实现父类的方法。
  • Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
  • 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。
1
2
3
4
5
class 父类 {
}
 
class 子类 extends 父类 {
}

1.5.1.4 多态

​ 多态是同一个行为具有多个不同表现形式或形态的能力。

​ 优点

  • 消除类型之间的耦合关系
  • 可替换性
  • 可扩充性
  • 接口性
  • 灵活性
  • 简化性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.ydl;

public class Test12 {
    public static void main(String[] args) {
    Person p = new Student();
    p.drink();
    }
}

class Person{
    public void drink(){
        System.out.println("water");
    }
}
class Student extends Person {

    public void drink() {
        System.out.println("tea");
    }
}
  1. 要有重写
  2. 有继承
  3. 父类引用指向子类对象

1.5.1.5构造方法

​ 构造方法包含初始化类的成员变量的代码，当类的对象在创建时，它自动执行，不管谁创建类对象，构造方法被激活，成员变量被初始化。

​ 特征：

  • 它具有与类相同的名称

  • 不能有返回值，写上void就是普通方法

  • 它不能在用return语句返回一个值

  • 构造方法必须与类名一致

    public class Employee {
    String EmployeeName; //姓名
    int EmployeeNo=45; //编号
    double Salary; //薪水
    public Employee(){


    }

1
2
3
4
调用：
	普通方法有static：类名.方法名(实参);
    普通方法没有static：引用.方法名（实参）;
	构造方法：在创建对象的时候被调用：new 构造方法（实参）

1.5.1.6 访问说明符和修饰符

修饰符 当前类 同一包内 子孙类(同一包) 子孙类(不同包) 其他包
public Y Y Y Y Y
protected Y Y Y Y/N N
default Y Y Y N N
private Y N N N N
1.final 修饰符：
  • 一个final 不能被继承
  • 一个final 不能被子类重载
  • final 成员变量不能在被初始化后被改变
  • 在final类里面所有的成员变量和方法都是final类型
2.abstract修饰符
  • 类中包含一个明确声明的抽象方法
  • 类中的任何一个父类包含一个没有实现的抽象方法
  • 抽象类必须有子类

1.5.1.7方法的重载

  • 方法名一样，形式参数不一样
  • 方法的参数类型，参数个不一样
  • 方法的返回类型可以不相同
  • 方法的修饰符可以不相同
1
2
3
4
5
6
7
8
9
10
public int add(int x,int y) {
      
      return x+y;
  }
  public int add(int x,int y,int z){
     return x+y+z;
  }
  public void add(int name){
      
  }

1.5.1.8this关键字

image-20221130155516527

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Employee {
    String EmployeeName;   //姓名
    int EmployeeNo=45;        //编号
    double Salary;          //薪水


    public Employee(String employeeName, int employeeNo, double salary){
        this.EmployeeName=EmployeeName;
        this.EmployeeNo=EmployeeNo;
        this.Salary=Salary;

    }
}

1.5.1.9super关键字

使用super调用父类的方法和属性，super 可以理解为是指向自己超（父）类对象的一个指针，而这个超类指的是离自己最近的一个父类。

  1. 父类开始找，父类没有才开始找子类
1
2
3
4
5
6
7
8
package com.ydl;

public class Father {
    String name="hdjk";
    public void ect(){
        System.out.println("在吃饭");
    }
}
1
2
3
4
5
6
7
8
9
10
package com.ydl;

public class Son extends Father {
    public  String name="金中豪";
    public void run(){
        String name="wang";
        System.out.println(this.name);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
package com.ydl;

public class Test {

    public static void main(String[] args) {
        Son son = new Son();

        son.run();
        System.out.println();
    }
}

1.5.2.0 toString方法

​ toString() 方法用于返回以一个字符串表示的 Number 对象值。

如果方法使用了原生的数据类型作为参数，返回原生数据类型的 String 对象值。如果方法有两个参数， 返回用第二个参数指定基数表示的第一个参数的字符串表示形式

1.5.2.1 对象转型

  • 向上转型：子类对象转为父类，向上转型不需要显示转化。Father father =son 向上转型会丢失子类原来有的特性。
  • 向下转型：父类对象转为子类，向下转型需要强制类型转换。Son son=(son)Father
1
2
3
4
5
6
7
8
9
10
11
12
public class Test {

    public static void main(String[] args) {
        Father s=new Son();  //自动类型转换
        s.ect();
        //强制类型转换
        Father s2=new Son();
        Son s3 = (Son) s2;
        s3.pary();
    }
}

1.5.2.2 抽象类

​ 用abstract关键字来修饰一个类时这个类就是抽象类。

  • 抽象类必须使用abstract关键字来修饰，抽象方法也必须用abstract来修饰。
  • 抽象类不能被实例化，不能使用new关键字生成对象。
  • 抽象方法只需声明，不需实现
1
2
3
4
public abstract class gh {
    int a;
    public abstract void M1();
}
  1. 类和类叫继承，类和接口之间叫实现。
  2. 继承使用extends 关键字。
  3. 实现用implements 关键字。
  4. 抽象使用abstract。
  5. 当一个非抽象类实现接口的话，必须将接口里面的抽象方法全部重写。
  6. 当一个非抽象类实现接口的时候必须将接口中所有方法加以实现。
  7. 一个类可以实现多个接口
  8. extends和implements可以共存，extends在前，implements在后。
  9. 使用接口，写接口的时候，可以使用多态（父类引用指向子类对象）

1.5.2.3接口

​ 接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义。

  • 接口是完成抽象的
  • 接口支持多继承
  • 接口中只包含部分内容，常量，抽象方法
  • 接口中所有的元素都是public
  • 接口中不能有方法体
1
2
3
4
public interface 接口名{
    //常量
    //方法声明
}
1
2
3
class 类名 extends 基类 implements 接口 接口{
	//成员定义
}

1.5.2.4代码块

​ 代码块又称初始化块，属于类中的成员，它讲的是逻辑代码块封装在方法体中通过{}包裹，代码块没有方法名，返回值，只有方法体，而且不通过对象和类进行调用，他会在类加载的时候调用，或创建对象的时候隐式调用。

  1. 静态代码块

一个类在加载的时候调用，做一些全局初始化的工作

1
2
3
static{

}

​ 2.实例代码块

每次创建实例都会被调用一次

1
2
3
{

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.ydl.template;

import com.ydl.Test;

public class block {
    static {
        System.out.println("nihao");
    }
    {
        System.out.println("buhap1");
    }

    public static void main(String[] args) {

        new block();
        new block();
        new block();

    }
}

1.5.2.4 静态方法和成员方法

​ 静态方法的调用无论在那都是类名.方法名

​ 静态方法中调用实例方法必须new一个对象。

1.5.2.4 内部类

​ 内部类就是在类里面定义了一个类。

1
2
3
4
5
6
7
8
9
10
11
package com.ydl.template;

import javax.xml.soap.Node;

public class Sperlinked {
    Node head;
    class Node {
        
    }
}

1.5.2.5 Java 异常处理

​ 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。

异常发生的原因有很多，通常包含以下几大类：

  • 用户输入了非法数据。
  • 要打开的文件不存在。
  • 网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。-

要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：

  • 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
  • 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
  • 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
1
2
3
4
5
6
7
8
9
10
11
12
捕获异常
使用 try 和 catch 关键字可以捕获异常。try/catch 代码块放在异常可能发生的地方。

try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下：

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

1.5.2.5throws/throw 关键字

​ 如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。

也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。

下面方法的声明抛出一个 RemoteException 异常：

1
2
3
4
5
6
7
8
9
10
import java.io.*;
public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}

例如，下面的方法声明抛出 RemoteException 和 InsufficientFundsException：

1
2
3
4
5
6
7
8
9
10
import java.io.*;
public class className
{
   public void withdraw(double amount) throws RemoteException,
                              InsufficientFundsException
   {
       // Method implementation
   }
   //Remainder of class definition
}

1.5.2.1 集合

​ 数组就是一个集合。其实集合就是一个容器。可以用来容纳其他类型的数据，集合是一个容器，是一个载体，可以一个容纳多个数据。

​ 集合不能直接存储基本数据类型，也不能直接存储Java对象，集合中存储的Java对象的内存地址，也可以说是引用。

  1. 集合在Java中本身就是一个容器，是一个对象，也有内存地址。
  2. 集合在任何时候存储的都是一个引用。
  3. Java中每一个不同集合，底层都会对应不同的数据结构，往不同的集合中存储元素等于将数据放入了数据结构当中。不同的数据结构数据的存储方式不同。