Java知识点汇总1

面向对象

“万物皆对象”怎么理解？
面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做；
面向对象：强调了具备了功能的对象，以类/对象为最小单位，考虑谁来做。

任何资源、变量等都可以看成是对象，每个对象都有自己的状态特征和行为特征，即属性和方法，面向对象思想是指在编程过程中，通过对象之间行为的交互来解决问题。

在Java语言范畴中，我们将功能、结构等封装到类中，通过类的实例化来调用功能结构，即通过"对象.属性"/"对象.方法"来调用；
涉及到Java相关的技术，包括前端HTML页面、后端数据库的交互、以及文件资源、网络资源URL等，都可视为对象；
以类的形式组织代码，以对象的形式封装数据；

类与对象

类是很多个具有相同属性和行为特征的对象所抽象出来的，对象是类的实例化；
总结：类是对象的抽象，对象是类的实例；

类的三大特征：
封装性：隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。

实现：属性的权限修改为private，并且创建getXxx()/setXxx()方法，用于调用private的属性(一般是类的成员变量)；
优点：

我们程序设计追求“高内聚，低耦合”。
①. 高内聚:类的内部数据操作细节自己完成，不允许外部干涉;
②. 低耦合:仅对外暴露少量的方法用于使用；
③. 更加安全；

缺点：不能直接访问private修饰的变量，增加访问难度。

继承性 ：子类可以继承父类的属性和方法，并能拓展新的属性和方法；

实现：使用extends关键字将多个类具有的共同属性与特征行为即成员变量/成员方法提取出来定义在一个公共类中，方便其他类继承；

Class A extends Class B{}

特点：java中类具有单继承性：一个类只能有一个直接父类，但一个类可以被多个子类继承；
优点：

①. 减少了代码的冗余，提高了代码的复用性，从而提高软件开发效率；
②. 便于功能扩展；
3.多态的前提；

缺点：父类变化，子类也会跟着变化，形成强耦合关系，应减少继承关系，降低耦合度。
tips：一旦子类A继承父类B之后，A就获取了B中声明的所有结构：属性、方法；
注：父类中声明为private的属性或方法，子类继承父类后，仍然认为获取了父类中的私有结构
只是因为封装性原因，使得子类不能直接调用父类的结构。

多态性(Polymorphism)：父类或接口定义的引用变量可以指向子类/具体实现类的实现对象。

多态实现的条件：

①. 子类继承父类并重写父类中已有的方法；
②. 父类引用指向子类对象，相同的引用调用同一个方法会根据子类对象的不同而表现出不同的行为；
③. 向上转型；

作用：

①. 应用程序不必为每一个派生类编写功能调用，只需对基类进行处理，提高代码的复用性；
②. 父类引用可以调用不同子类的功能(向后兼容)，提高了代码的扩展性和可维护性；

分类：
编译时多态 (方法的重载overload)
运行时多态(方法的重写override)
体现:
Java引用变量有两个类型:编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。
若编译时类型和运行时类型不一致，就出现了对象的多态性。

Animal a = new Dog();
a.eat();//调用的方法必须是子父类都有的

总结：编译看左边（父类的引用），运行看右边（子类的对象）

重载与重写
重载：功能类似的方法，可以使用相同的方法名来定义不同功能的方法；在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

特点：

①. 与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。
②. 调用时，根据方法参数列表的不同来区别。

在通过对象调用方法时，如何确定某一个指定的方法？

JVM会根据参数类型、个数、顺序等找到相对应的方法并运行；

重写：子类继承父类之后，可以对父类中同名同参数的方法，进行覆盖操作；

应用：重写以后，当创建子类对象后，通过子类对象调用子父类中的同名同参数时，执行的是子类重写的方法
方法的声明：
权限修饰符返回值类型方法名(形参列表)throws 异常的类型{}：
重写的规定：

①. 子类重写的方法的方法名和形参列表与父类中被重写的方法名和形参列表相同
②. 子类重写的方法的权限修饰符>=父类被重写方法的权限修饰符
特殊情况：子类不能重写父类中private的方法；

返回值类型:

①. 父类被重写的方法的返回值类型void，子类也必须是void
②. 父类：A类(Object) 子类：A类/A类的子类(String)
③. 父类：基本数据类型(double) 子类：相同的基本数据类型(double)

子类重写的方法抛出的异常类型<=被重写的方法抛出的异常类型
tips:

子类和父类中的同名同参数的方法要么都static(不是重写)，要么都非static(考虑重写)
static方法是随着类的加载而加载的，不能被覆盖/重写

若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中；
对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量。
eg:

class Base {int count = 10;public void display() {System. out. println(this. count);}
}
class Sub extends Base{int count = 20;public void display() {  System. out. println(this. count);}
}public class FieldMethodTest {public static void main(String[] args) {Sub s = new Sub();System. out. println(s.count);   //20   声明的是Sub，先找自己再找父类。s.display();  //20?  display()重写Base b = s;  //多态性//==,对于引用数据类型，比较的是两个引用数据类型变量的地址值是否相同System. out.println(b == s);//trueSystem. out . println(b. count);  //10，多态性 属性看左边b.display();   //20  虚拟方法调用，调用父类，实际执行子类(子类重写了)//(成员变量/静态方法)(属性不具有多态性！)看左边，方法看右边}
}

对于多态的调用：成员变量/静态方法看左边，方法看右边。

重载与重写的区别：
1.从编译和运行的角度看:
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
所以:对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为 “早绑定” 或 “静态绑定”;
而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为 “晚绑定” 或 “动态绑定”。

数组

二维数组
规定：二维数组分为外层数组的元素，内层数组的元素：

int[][] arr = new int[4][3];
//外层数组元素：arr[0], arr[1]……
//内层数组元素：arr[0][0], arr[0][1]……

数组元素的默认初始化值
二维数组有两种默认初始化：

初始化方式一：int[][] arr = new int[4][3];
初始化方式二：double[][] arr2 = new double[4][]；

针对于初始化方式一：int[][] arr = new int[4][3];
外层元素的初始化值为：地址值
内层元素的初始化值：与一维数组初始化情况相同
针对于初始化方式二：double[][] arr2 = new double[4][]；
外层元素的初始化值为：null，指针指向的地址没有值；
内层元素的初始化值：不能调用，否则空指针异常，指针没有初始化值代表指针没有指向任何东西，为空。

形参传递机制

方法的形参的传递机制：值传递；

如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值；

如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值；

匿名对象

定义：我们创建的对象，没有显式的赋给一个变量名，为匿名对象；
特征：匿名对象只能调用一次；

this关键

使用情况

this可以用来修饰：属性、方法、构造器
this修饰属性和方法： this理解为：当前对象

this调用属性/方法

一般情况下：通过 " this.属性 " / " this.方法 "的方式调用当前对象的属性/方法，只不过通常情况下省略了this;
特殊情况下：如果方法的形参和类的属性重名，必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参(若不使用this，则会默认就近原则调用形参)；
eg1:

public void eat(){System.out.println("吃饭");study();  //相当于 this.study();  省略了this}public void study(){System.out.println("学习");}

eg2:

class Person{private int age;private String name;public void setName(String name){  //形参名和属性名相同，会覆盖成员变量// name  = name;  就近原则this.name = name;}
}

this调用构造器

在类的构造器中，可以显式的使用"this(形参列表)“方式,调用本类中指定的"其他构造器”；
构造器中不能通过this(形参列表)"方式调用自己；
如果一个类中又n个构造器，则最多有n-1个构造器使用"this(形参列表)"方式;
规定："this(形参列表)"必须声明在当前构造器的首行,“Call to ‘this()’ must be first statement in constructor body”;
构造器内部：最多只能声明一个"this(形参列表)"，用来调用其他构造器,不能多次调用，不能循环调用；

 public Person(){  //构造器0System.out.println("我是千万万个冗余代码");//创建空参构造器，可以放置冗余代码// 下面的构造器可以直接调用上面放置冗余的构造器}public Person(int age){  //构造器1this();  //调用构造器0this.age = age; / /如果正在构造器内调用，this可以理解为“当前正在创建的对象的属性”}public Person(String name,int age){  //构造器2this(age);// 调用构造器1this.name = name;}