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、setpublic 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());}
}

作用(意义)：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护性增加了

继承

继承的本质是对某一批类的抽象，从而实现对世界更好地建模。
extends的意思是”扩展“。子类是父类的扩展，使用关键字extends来表示。
Java中类只有单继承，没有多继承！一个类只能继承一个父类。
继承是类与类之间的一种关系，此外还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）子类继承父类。
子类和父类之间，从意义上讲应该具有”is a“的关系。

public class Person /*entends Object*/{//public//protected//default//privateprivate 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类

super()调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或构造方法中
super()和this()不能同时调用构造方法，因为this也必须写在第一行

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

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

super注意点：

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中！
super和 this 不能同时调用构造方法！

Vs this:

代表的对象不同：

this:本身调用者这个对象
super:代表父类对象的应用

前提

this：没哟继承也可以使用
super：只能在继承条件才可以使用

构造方法

this()：本类的构造
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的方法
*/

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

注意点：

方法名、参数列表必须相同
修饰符范围可以扩大，不能缩小（public>protect>private）
抛出的异常范围可以被缩小，不能扩大
被static(属于类，不属于实例)，final(常量方法)，private(私有)修饰的方法不能重写

多态

动态编译：类型
即同一方法可以根据发送对象的不同而采用不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用可以有很多
多态存在条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象

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

static 方法，属于类，它不属于实例
final 常量;
private方法;

instanceof和类型转换

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

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

类型转换

父类引用指向子类的对象
把子类转换为父类，向上转型，会丢失自己原来的一些方法
把父类转换为子类，向下转型，强制转换，才调用子类方法
方便方法的调用(转型)，减少重复的代码，简洁。

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 finalpublic static final int AGE = 99; //一般不用//所有的定义的方法都是抽象的 默认public abstractpublic 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.在出现异常方法的调用者中捕获并处理异常。