Java初步学习部分总结

学习Java之后的一些知识笔记，比较零散，希望能够帮到大家，有错误的内容还请各位指正

面向对象（Object Oriented,OO）

Java语言最大的特点：是一种对现实世界理解和抽象的方法

核心思想：人类思考问题的基本方式，所有方式抽象为对象

面向对象的特点：继承、封装、多态

面向对象与面向过程的区别

面向过程：传统的程序设计思路。将一个问题看成是一些类函数或模块的集合。自顶向下。​灵活性和扩展性不足

对象

对象是一个具体实例，包含自己的属性和属性值

类

类是指的具有相同属性和行为的一组对象的集合

对象和类的关系

表面理解：类是对象的集合。

严谨的解释：对象是类的实例化，而类是对象的抽象。

封装

不对外暴露数据，通过方法调用。（方法的修饰符为public）
好处：
（1）实现数据访问权限的控制
（2）实现数据赋值的规范化、标准化等的管控
提供了公共的访问方式，但是隐藏了变量实现的细节（set、get方法）

public void setValue(数据类型 变量名){
	this.变量名 = 变量名;
}
public 数据类型 getValue(){
	return 变量名;
}

Tips：在其他类中对变量赋值调用set方法,获取变量用get方法

构造函数

是一种特殊的方法，主要用来初始化对象的成员变量。如果成员变量比较多，要实现赋值调用多次set方法，通过构造函数来解决。

（1）构造函数与类名时相同的，在对象实例化时由虚拟机自动调用

（2）构造函数没有返回值类型，也不能有返回值

（3）每个对象生成时都必须执行构造函数，而且只执行一次

（4）如果构造函数调用失败，那么对象也将创建失败

（5）在没有定义构造函数的时候，类会自动产生一个无参的默认构造函数。这个构造函数什么都不会有

（6）一旦显式定义了构造方法，默认的构造方法会自动消失

构造函数重载

this关键字

区分成员变量与局部变量

this是一个关键字，表示当前类的对象。哪个对象调用了this所属的方法，这个this就代表对象。

（1）this可以调用类中的属性（成员变量、方法） this.

（2）如果要在一个构造方法中调用另外一个构造方法来初始化信息，可以使用this()。但必须放在第一行

this(参数名);代表调用了当前对象的构造函数，表示调用成员变量

this在不同的对象调用时表现不同

static关键字

是一个修饰符，用来修饰类的成员（属性、方法）

类加载时就加载静态成员（运行和初始化）

静态成员的初始化优于对象的初始化

静态的成员（属性和方法）可以通过类名.操作符直接访问(可以直接用类名.方法来调用这个静态方法；可以直接用类名.属性给变量赋值)

静态代码块优先级比构造器高，随着类的加载初始化，静态变量都在里面赋值和初始化

static{方法体};

构造代码块{}无static修饰的

构造代码块随着对象的创建而执行，每次创建对象都会执行，对变量没有要求（可以初始化静态变量，也可以初始化非静态变量）。

静态代码块优先级最高，其次是构造代码块，最后才是构造器。

创建一个子类对象时，先父类静态代码块、子类静态代码块，然后是父类构造代码块、父类构造方法、子类构造代码块、子类构造方法

继承

多个类中存在相同的属性和方法时，可以将这些内容抽取到一个类中，那么多个类就无需再定义这些属性和方法，只要继承就可以
父类又称为基类，子类称为派生类。子类可以直接访问父类中的非私有属性和方法（非private修饰的）。
子类不能够继承父类中的构造方法，用super来调用
class 子类名 extends 父类名{成员}
通过继承实现了编程的多样性，多态

继承中方法的重写

如果子类和父类具有相同的方法，子类的这个方法就叫重写。如果父类是抽象类，子类如果没有覆写全部抽象方法，那么子类也需要关键字abstract修饰。继承抽象类的时候必须要实现抽象方法，可以不用全部实现。

static方法不能重写但可以继承。在Java中，如果父类中含有一个静态方法，且在子类中也含有一个返回类型、方法名、参数列表均与之相同的静态方法，那么该子类实际上只是将父类中的该同名方法进行了隐藏，而非重写。换句话说，父类和子类中含有的其实是两个没有关系的方法，它们的行为也并不具有多态性。

Java中的接口是支持多继承的,类可以同时实现多个接口

由于接口是一种抽象形式，其中的所有方法只有声明而没有方法体，所以当一个类实现多个接口还活着一个接口继承多个接口时，即使不同接口都含有同样的方法（即方法完全相同）也不会因为这个而不知该实现哪个接口中的方法，因为所有方法都是一样的。

而类就不同了，因为每个类中的方法必须有自己的实现，当A类和B类中同时出现方法Function()，如果此时C类同时继承了A类和B类，那么到底该选择哪个Function()就是一种歧义，因为两个方法的方法体也许是完全不同的逻辑。

public interface A extends B,C{
​ //注意关键字是extends，接口与接口之间只有继承没有实现
}

super

三种用途

1. 在子类的构造方法中，super关键字可以显式地调用父类的构造方法，用于将参数传递给它。
2. 如果父类和子类有同名的成员变量，在子类中默认访问属于自己的成员变量。
3. 如果子类重写了父类的方法，子类又需要调用父类的被重写的方法。
   通过super();来调用父类的构造函数

final关键字

主要修饰类（final class）、方法（final function）、变量（final 变量）

1. 如果一个类被final修饰，那么这个类就不允许被继承
2. 如果一个方法被final修饰，那么这个方法就不允许被重写
3. final修饰的变量不能够被改写，但是能够被继承

Object类

Object是一个顶级父类，所有类的父类。可以显示地继承，也可以隐式地继承

方法摘要：

1. clone():创建并返回此对象的一个副本
2. equals():指示其他某个对象是否与此对象“相等”
3. finalize():当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法
4. getClass():返回此Object的运行时类
5. hashCode():返回该对象的哈希码值
6. notify():唤醒在此对象监视器上等待的单个线程
7. notifyAll():唤醒在此对象监视器上等待的所有线程
8. toString():返回该对象的字符串表示
9. wait():在其他线程调用此对象的notify()方法或notifyAll()方法前，导致当前线程等待
10. wait(long timeout):在其他线程调用此对象的notify()方法或notifyAll()方法，或者超过指定的时间量前，导致当前线程等待
11. wait(long timeout,int nanos):在其他线程调用此对象的notify()方法或notifyAll()方法，或者其他某个线程中断当前线程，或者已超某个实际时间量前，导致当前线程等待

public boolean equals(Object obj){

	return (this == obj);}

this是调用对象，obj代表传递的参数对象

this == obj   引用类型 == 比较对象的内存地址

内存地址不同，返回值false

所以我们需要重写equals方法

public String toString(){

​	return getClass().getName()+"@"+Integer.toHexString(hashCode())}

String类中重写了equals方法，比较的是字符

多态

多种表现形态

多态是指一个引用类型在不同的情况下的多种状态

1. 重载式多态——静态多态
   重载：具有相同的函数名，但参数列表不同

2. 动态多态——主流的
   a.继承：在多态中必须存在继承关系的子类和父类
   b.重写：子类对父类中的某些方法进行了重新定义，在调用该方法时，就实现了动态选择
   c.子类引用赋给父类的对象——向上转型。

   如果子类没有该方法，就直接调用父类中的方法

   Father father = new Son();
   

向上转型或向下转型

1. 子类引用的对象转换为父类类型称为向上转型。父类对象可以是接口

   Father father = new Son();

向上转型的好处：减少重复代码，使代码变得简洁；提高系统扩展性。
父类引用指向子类的对象的时候，父类所能看到的只是属于父类的那部分属性和方法。

3. 父类引用的对象转化为子类类型称为向下转型（先有向上转型，才能向下转型）。

   Father father = new Son();
   Son son = (Son) father;

向下转型可以得到子类的所有方法（包括父类的方法）

向上转型会丢失子类的新增方法，同时会保留子类重写的方法。

Tips：instanceof
obj instanceof obj 做判断，判断前面的对象是否是后面的类或者其子类、实现类的实例，返回boolean的数据类型

内部类

将一个类定义在另一个类里面或者在一个方法里面，这样的类叫做内部类。

为什么要有内部类呢？

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
3. 内部类所实现的功能使用外部类同样可以实现，只是有时候用内部类更方便

内部类分类

成员内部类：将内部类定义为一个成员变量，只不过这个成员变量的数据类型是个类（成员内部类没有static关键字）

静态内部类：用static修饰的成员内部类就叫做静态内部类

局部内部类：定义在一个方法里面（代码块{}、作用域）

匿名内部类：定义在一个方法里

成员内部类详解

1. 成员内部类：成员内部类可以访问外部类的成员变量

2. 当成员内部类与外部类具有相同的成员变量名时，会发生隐藏现象，默认情况下访问成员内部类的成员
   如果必须访问外部类的同名成员，需要通过以下形式：
   外部类名.this.成员变量名（不能不加this，除非是静态变量）

3. 外部类访问成员内部类
   必须创建一个内部类的对象，通过对象来访问
   外部类名.内部类名 对象名 = new 外部类构造器.new 内部类构造器;
   外部类名.内部类名 对象名 = 外部类对象.new 内部类构造器;

4. 成员内部类初始化
   第一种，通过外部类对象创建内部类对象的方式
   第二种，通过方法直接获得内部类的对象

5. 应用场景
   可以处理复杂的应用场景，实现多继承

静态内部类

用static修饰的成员内部类就是静态内部类

1. 不能调用外部类非静态属性和方法，可以直接通过类名.成员名调用
2. 外部类访问内部类方法
   外部类名.内部类名 对象 = new 外部类名.内部类构造器；

局部内部类

相当于方法里面的局部变量，不能用public、private、protected修饰

在代码块{}、方法体：function(){}中的类