java学习记录最后一篇

面向对象编程

封装

该露的露，该藏的藏

• 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）

• 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，称为信息隐藏。

记住这句话就够了：属性私有，get/set

package OOP.demo04;
//类
public class Student {
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄
    //提供一些可以操作这个属性的方法
    //提供一些public 的get，set方法
​
    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
​
    //alt+insert 自动生成get、set
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
​
    public char getSex() {
        return sex;
    }
    public void setSex(char sex) {
        this.sex = sex;
    }
​
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age>120||age<0){
            this.age=3;
        }else{
            this.age = age;
        }
​
    }
}



​
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
​
        s1.setName("yun");
        System.out.println(s1.getName());
        s1.setAge(999);//不合法的
        System.out.println(s1.getAge());
    }
}

​

作用(意义)：

1. 提高程序的安全性，保护数据

2. 隐藏代码的实现细节

3. 统一接口

4. 系统可维护性增加了

继承

• 继承的本质是对某一批类的抽象，从而实现对世界更好地建模。

• extends的意思是”扩展“。子类是父类的扩展，使用关键字extends来表示。

• Java中类只有单继承，没有多继承！一个类只能继承一个父类。

• 继承是类与类之间的一种关系，此外还有依赖、组合、聚合等。

• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）子类继承父类。

• 子类和父类之间，从意义上讲应该具有”is a“的关系。

public class Person /*entends Object*/{
    //public
    //protected
    //default
    //private
    private int money=10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }
​
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
}
​
​
//学生 is 人 ：派生类，子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{
//Ctrl+H 树状图，查看类关系
}
​
​
//老师 is 人
public class Teacher extends Person{
​
}
​
​
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
    }
}

• 在Java中，所有类，都默认直接或间接继承Object类 (Ctrl+H 可以查看类关系)

• 被final修饰的类，无法被继承（断子绝孙）。

Super类 & this类

1. super()调用父类的构造方法，必须在构造方法的第一个

2. super必须只能出现在子类的方法或构造方法中

3. super()和this()不能同时调用构造方法，因为this也必须写在第一行

• super与this的区别：super代表父类对象的引用，只能在继承条件下使用；this调用自身对象，没有继承也可以使用。

super(); //隐藏代码，默认调用了父类的无参构造，要写只能写第一行

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个

2. super必须只能出现在子类的方法或者构造方法中！

3. super和 this 不能同时调用构造方法！

Vs this:

• 代表的对象不同：

1. this:本身调用者这个对象

2. super:代表父类对象的应用

• 前提

1. this：没哟继承也可以使用

2. super：只能在继承条件才可以使用

• 构造方法

1. this()：本类的构造

2. super()：父类的构造

学习地址：面向对象10：Super详解_哔哩哔哩_bilibili

方法的重写

• 重写：子类的方法必须与父类方法必须一致，方法体不同。

• 重写是方法的重写，与属性无关

• 重写方法只与非静态方法有关，与静态方法无关（静态方法不能被重写）

public class B {
    public static void test(){ //静态方法
        System.out.println("B==>test()");
    }
}

public class A extends B{ //继承
    public static void test(){
        System.out.println("A==>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        //方法的调用之和左边定义的类型有关
        A a = new A();
        a.test(); //打印 A==>test()
​
        //父类的引用指向了子类，但静态方法没有被重写
        B b = new A();
        b.test(); //打印 B==>test()
    }
}

修改A.java, B.java

public class B {
    public void test(){ //非静态方法
        System.out.println("B==>test()");
    }
}
public class A extends B{
    @Override //重写了B的方法
    public void test() {
        System.out.println("A==>test()");
    }
}

//父类的引用指向了子类
B b = new A(); //子类重写了父类的方法，执行子类的方法
b.test(); //打印变成了 A==>test()
/* 
静态方法是类的方法，非静态方法是对象的方法
有static时，b调用了B类的方法，因为b是b类定义的
没有static时，b调用的是对象的方法，而b是A类new出来的对象，调用A的方法
*/

• 静态方法属于类，非静态方法属于对象

注意点：

1. 方法名、参数列表必须相同

2. 修饰符范围可以扩大，不能缩小（public>protect>private）

3. 抛出的异常 范围可以被缩小，不能扩大

4. 被static(属于类，不属于实例)，final(常量方法)，private(私有)修饰的方法不能重写

多态

• 动态编译：类型

• 即同一方法可以根据发送对象的不同而采用不同的行为方式

• 一个对象的实际类型是确定的，但可以指向对象的引用可以有很多

• 多态存在条件

  • 有继承关系

  • 子类重写父类方法

  • 父类引用指向子类对象

多态注意事项： 1.多态是方法的多态，属性没有多态 2.父类和子类，有联系 类型转换异常！ClassCastException! 3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();

1. static 方法，属于类，它不属于实例

2. final 常量;

3. private方法;

instanceof和类型转换

instanceof 引用类型比较，判断一个对象是什么类型

public static void main(String[] args) {
​
    // Object > String
    // Objest > Person > Student
    // Objest > Person > Teacher
    Object object = new Student();
    // X instanceof Y，X引用指向的对象是不是Y的子类
    System.out.println(object instanceof Student); //true
    System.out.println(object instanceof Person); //true
    System.out.println(object instanceof Teacher); //false
    System.out.println(object instanceof Object); //true
    System.out.println(object instanceof String); //false
    
    //类型之间的转化：父-子（高-低）,低可以转换为高
    Person obj = new Syudent(); //只能用Person方法（重写了用子类重写过的方法）
    (Syudent)obj.go(); /转之后可以用Student方法(Student->go())
}

类型转换

1. 父类引用指向子类的对象

2. 把子类转换为父类，向上转型，会丢失自己原来的一些方法

3. 把父类转换为子类，向下转型，强制转换，才调用子类方法

4. 方便方法的调用(转型)，减少重复的代码，简洁。

Static

• 静态变量可以直接用类名访问，也称类变量。

• 静态变量(或方法)对于类，所有对象（实例）所共享。

• 静态区代码 加载类时一起被初始化，最早执行且只执行一次（第一次new）。

• Math->随机数:

//静态导入包
import static java.lang.Math.random;
​
public class Application {
    public static void main(String[] args) {
​
        //第一种随机数，不用导包
        System.out.println(Math.random()); //0.7562202902634543
​
        //第二种随机数，静态导入包
        System.out.println(random()); //0.5391606223844663
    }
}

抽象类(abstract)

• abstract修饰的类就是抽象类，修饰的方法就是抽象方法。

• 抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类。

• 抽象类不能使用new来创建对象，它是用来让子类继承的。

• 抽象方法只有方法的声明，没有实现，让其子类实现。

• 子类继承抽象类，必须实现抽象类的所有方法，否则该子类也要声明为抽象类。

//abstract 抽象类 类只能单继承（接口可以多继承）
public abstract class Action {
​
    //约束~有人帮我们实现~
    //抽象方法只有方法名，没有方法的实现
    public abstract void doSth();
​
    //1.不能new抽象类，只能靠子类去实现它，仅作为一个约束
    //2.抽象方法只能出现在抽象类中，抽象类可以有普通方法
    //3.抽象类有构造器，可以派生子类
    //4.抽象类的意义：约束，提高开发效率。但是类只能单继承，所以有局限 用的不多
}

接口(interface)

• 普通类：只有具体实现

• 抽象类：具体实现和规范(抽象方法)都有

• 接口：只有规范，没有方法实现，专业的约束！约束与实现分离：面向接口编程~

• 接口就是规范，定义的是一组规则，"你是什么…必须做什么…"的思想。

• 接口的本质是约束，就像人间法律一样，制定好大家都遵守。

//interface接口,接口都要有继承类
//实现类（implements 可以继承多个接口）
//多继承，利用接口实现多继承
public interface UserService {
    //定义的属性都是常量,默认修饰 public static final
    public static final int AGE = 99; //一般不用
    //所有的定义的方法都是抽象的 默认public abstract
    public abstract void run();
    void add();
    void query();
    void delete();
}

注意点

• 接口没有构造方法，不能被实例化

• 实现类必须要重写接口中的方法

• 实现类（implements） 可以实现多个接口

内部类

• 内部类就是在一个类的内部再定义一个类，比如A类中定义了一个B类，那么B就是A的内部类，而A相对B来说就是外部类

  1. 成员内部类：可以操作外部类的私有属性及方法

  2. 静态内部类：static修饰，不能访问外部类私有属性

  3. 局部内部类：外部类的方法里定义的类

  4. 匿名内部类：没有名字初始化类

异常

• 软件程序在运行过程中，经常可能遇到异常问题，异常英文(Exception)，意思是例外，这些例外情况需要我们写程序做出合理的处理，而不至于让程序崩溃。

• 异常指程序运行中出现的不期而至的各种状况：文件找不到，网络连接错误，非法参数等。

• 异常发生在程序运行期间，它影响了正常的执行流程。

什么是异常

• 实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求、你的程序要打开某个文件，这个文件可能不存在或者文件格式不对，你要读取数据库的数据，数据可能是空的等。我们的程序再跑着，内存或硬盘可能满了，等等。

• 软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是:Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃。

• 异常指程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。

• 异常发生在程序运行期间，它影响了正常的程序执行流程。

简单分类

• 检查型异常：最具代表性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如用户要打开一个不存在的文件时引发的异常，这些异常在编译时不能被简单地忽略。

• 运行时异常：是可能被程序员避免的异常，与检查性异常相反，运行时异常可以在编译时忽略。

• 错误Error：错误不是异常，而是脱离程序员控制的问题。错误在代码经常被忽略。例如当栈溢出，一个异常就发生了，它们在编译也检查不到。

异常体系结构

• Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。

• 在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。

Error

• Error类对象由Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。

• Java虚拟机运行错误（Virtual MachineError），当JVM不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止;

• 还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误(LinkageError）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。

Exception

• 在Exception分支中有一个重要的子类RuntimeException（运行时异常)

  • ArraylndexOutOfBoundsException（数组下标越界)

  • NullPointerException(空指针异常)

  • ArithmeticException（算术异常)

  • MissingResourceException（丢失资源)

  • ClassNotFoundException(找不到类）等异常，这些异常是不检查异常，程序中可以选 择捕获处理，也可以不处理。

• 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生;

• Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

异常处理机制

• 抛出异常

• 捕获异常

• 异常处理关键字：try、catch、finally、throw、throws

public static void main(String[] args) {
    int a = 1;
    int b = 0;
​
    try { //try监控区域
        System.out.println(a/b);
    }catch (ArithmeticException e){ //catch 捕获异常
        System.out.println("程序出现异常，变量b不能为0");
    }catch (Exception e){
        e.printStackTrace();
    }finally { //一定会执行，处理善后工作，如关闭资源
        System.out.println("finally");
    }
    
    if(b==0){ //抛出异常一般在方法中使用
        throw new ArithmeticException(); //主动抛出异常
    }
}
//Ctrl+Alt+T 快捷键插入 try-catch

自定义异常

• 使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。

• 在程序中使用自定义异常类，大体可分为以下几个步骤: 1.创建自定义异常类。 2.在方法中通过throw关键字抛出异常对象。 3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

  4.在出现异常方法的调用者中捕获并处理异常。

实际应用中的经验总结

• 处理运行时异常时，采用逻辑去合理规避同时辅助 try-catch 处理

• 在多重catch块后面，可以加一个catch （Exception）来处理可能会被遗漏的异常

• 对于不确定的代码，也可以加上try-catch，处理潜在的异常

• 尽量去处理异常，切忌只是简单地调用 printStackTrace()去打印输出

• 具体如何处理异常，要根据不同的业务需求和异常类型去决定

• 尽量添加finally语句块去释放占用的资源

学习地址： JavaSE总结_哔哩哔哩_bilibili

java学习记录笔记全部结束。