Java面向对象编程

知识小Tip:
一：类中静态成员变量与非静态成员变量的区别
（1）生命周期：
静态成员变量从类被加载开始到被类卸载，一直存在。
普通成员变量只有在类创建对象后才开始存在，对象结束，它的生命也就告终。
（2）共享方式：
静态成员变量是全类共享的
普通成员变量是每个对象单独享用的
二：类中静态方法与普通方法的区别
（1）静态方法通过类名调用；普通方法的调用必须使用对象
（2）普通方法在编译时，会给函数的形参默认加一个this引用变量，谁调用这个方法，就引用谁，故需使用对象调用，静态方法没有this引用变量。

以上知识来源：https://blog.csdn.net/sunny_668866/article/details/78388381

this的三种用法：

• this.成员变量
• this.成员方法
• this() 调用当前对象的构造方法

静态和动态的区别
静态指编译期就能确定的。
动态指编译期确定不了，运行时才能确定的。

一：包

包是什么：包是组织类的一种方式。使用包的主要目的是保证类的唯一性

包的创建及命名习惯

当在同一个类中，有两个不同的包中的类名冲突的时候，在这种情况下需要使用完整的类名。

import java.util.*;
import java.sql.*;

public class Test{
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
    }
}

静态导入（了解）

使用import static 可以导入包中的静态的方法和字段

import static java.lang.Math.*;
import static java.lang.System.*;
public class Test{
    public static void main(String[] args) {
        double x=30;
        double y=40;
        //静态导入可以更方便的写一些代码
        double result = sqrt(pow(x,2)+pow(y,2));
        out.println(result);
    }
}

包的访问权限：成员变量或者成员方法没有限制符修饰的话就是包内访问权限，包的访问权限为同一个包内访问，包外不能访问。

常见的系统包
java.lang：系统常用基础类（String、Object），此包从JDK1.1后自动导入；
java.lang.reflect：java反射编程包；
java.net：进行网络编程开发包；
java.sql：进行数据库开发的支持包；
java.util：是java提供的工具程序包。（集合类等）
java.io：I/O编程开发包；

二：继承（protect super）

使用继承的目的：继承的目的是为了达到代码重用的目的。
语法：class 子类 extends 父类{
}

• 使用extends指定父类
• java中一个子类只能继承一个父类
• 子类会继承父类的所有public，private等的字段和方法，但是子类无法访问父类的private的字段和方法。
• 子类的实例中，也包含着父类的实例，可以使用super关键字得到父类实例的引用。

protect关键字：类内部能访问，同一个包中的类可以访问，子类可以访问。

final关键字：final关键字也能修饰类，此时表示被修饰的类就不能被继承

• final int a =10; 常量 a的值不可以再发生改变
• final 修饰了类 密封类 当前类再不可以进行继承
• final 修饰方法 密封方法

父类和子类的构造方法相关知识：

• 当子类继承了父类之后，那么在构造子类的时候，一定要先帮助父类进行构造。在子类构造函数中，利用super()显示调用父类的构造方法，super()一定要放在第一行。

• 当子类和父类有重名的成员变量的时候，从内存结构图方向去考虑，用super去调用父类的成员变量，this调用子类的成员变量。

三：组合

组合也是表达类之间关系的方式，也是能够达到代码重用的效果

class student{
}
class teacher{
}
public class school{
	public student[] student;
	public teacher[] teacher;
}

四：多态

向上转型：

Cat cat = new Cat();
Animal animal = Cat;
//两种表达方式
Animal animal = new Cat();

向上转型的三种时机

• 直接赋值

Animal animal = new Cat();

• 函数传参

Cat cat = new Cat();
func(cat){
}

public static void func(Animal animal){
	animal.eat();
}

• 函数的返回值

public static Animal func(){
	Cat cat = new Cat();
	return Cat;
}

向上转型的作用：多态

如果发生了向上转型，那么通过父类引用，来调用方法或者成员变量的时候，只能调用父类自己的成员变量或者方法！

向下转型（父类类型转换成子类类型）

1. 父类引用给子类的时候，必须强制类型转换

Animal animal = new Bird("花花");
Bird bird = (Bird)animal;
bird.fly();

2. 向下转型，使用情况不多，因为向下转型，非常的不安全。

Animal animal = new Cat("花花");
if(animal instanceof Bird){
	Bird bird = (Bird)animal;
	bird.fly();
}

动态绑定
前提：

• 要先向上转型（父类引用 引用 子类对象）
• 通过父类引用 来调用父类和子类 同名的覆盖方法（重写Override）

重写 （Override）

1. 父类和子类里边
2. 方法名称相同
3. 方法的参数列表相同
4. 方法的返回值相同（返回值构成父子类关系也可以。此时，叫做：协变类型）

重载（Overload）

1. 方法的函数名相同
2. 方法的参数列表不同（数据类型和个数）
3. 方法的返回值不做要求
4. 重载不要求必须是同一个类（父类和子类之间或者同一个类当中）

重写还需要注意的几点：

• 子类的重写的这个方法，他的访问修饰限定符，一定要大于或等于父类的访问修饰限定符
• 要重写的方法不能被final修饰 如果被final修饰了，那么这个方法，就不能被改变，也说明，这个方法不能被重写
• 被static修饰的方法，是不能被重写的
• 添加@Override注解。一旦这个注解修饰了这个方法，只要不满足重写的条件，就会报错。

构造方法中调用重写方法，也可以发生动态绑定。

多态是一种思想：一个事物，表现出不同的形态。
封装是为了安全性考虑：

private能不能修饰构造方法？
可以修饰构造方法，但是这个构造方法，只能在当前类进行调用。用private修饰构造方法会在单例设计模式用到。

多态的好处：

• 降低了类的使用成本
• 降低了圈复杂度，避免使用大量的if else
• 可扩展能力强

五：抽象类（abstract）

包含抽象方法的类，叫做抽象类
抽象方法：如果一个方法，没有具体的实现，那么就可以用abstract来修饰。

• 抽象类不能被实例化。
• 抽象类当中，可以包含抽象方法，也可以包含非抽象方法。
• 当一个普通的类，继承了一个抽象类，那么这个普通类一定要实现抽象类当中的方法。
• 当一个普通类，继承了上述第四条说的那个抽象类，那么重写就是两个抽象类的抽象方法了。
• 抽象类本身是不可以被实例化的，要抽象类的目的就是为了继承，所以，抽象类和抽象方法都不能被final关键字修饰。同时抽象方法不能是private的。
• 父类的普通方法，在类外也可以被调用，但是需要让父类引用去引用子类对象。或者子类中用super访问父类（抽象类）的成员变量或者成员方法。
• 抽象类最大的意义就是为了被继承。

六：接口（interface）

• 接口当中的方法，默认都是抽象方法。public abstract
• 接口当中，可以定义成员变量。成员变量默认都是public static final
• 接口当中的所有方法，都是没有具体的实现的
• 在jdk1.8开始，接口中的方法可以有具体实现，但是这个方法必须是default修饰的。
• 接口也是不可以被实例化的。
• 接口的使用：类 implements 接口
• 一个类可以实现多个接口。通过关键字implements。但是注意，一定要重写每个接口的方法
• 如果两个接口，方法名相同，此时在类当中，只需要重写这一个方法就好了。但是最终调用的，就是这一个方法。建议既然接口都不一样，那么就不要有同样的方法了。
• interface D extends A,B 一个接口可以扩展多个接口，也就是说。D接口，具备了A和B接口的功能。如果将来D接口被实现，那么这个实现D接口的类，就要重写A,B,D 3个接口的方法了。

抽象类和接口的区别？

1. 成员变量
   抽象类当中：成员变量和普通的成员变量的定义没有区别
   接口当中：成员变量 默认是public static final
2. 成员方法
   抽象类当中：成员方法可以有普通的方法也可以有抽象方法
   接口当中：默认是Public abstract
3. 实现方式
   抽象类：不能被实例化，所以只能被子类使用extends关键字继承，且只能继承一个
   接口：不能被实例化，只能用implements来实现。同时一个类可以实现多个接口，一个接口可以使用extends，扩展多个接口的功能。