JAVA基础知识：面对对象特性【继承】【 多态】【 封装】【 接口】

不同的包之间不能直接调用另一个包中的类来实例对象。

需要用import 关键字来导入另一个包的类到这个包中才可以通过另一个包的类来实例化对象。

导入的方式为 关键字 import 加 另一个包的包名 如果叫：package1 接着加上.另一个包中需要调用的类名
具体格式是：import package1.Employee 意思就是导入了package1包中的Employee类到本包中。

关于取名：包名小写，类名的首字母最好大写。这是一种约定

class前面如果没有public 关键字 那么这个类就不可见，无法被其他包调用。只能本包中使用。

那么我如何通过其他的方法来调用这个不可见的类呢？并且使用它的方法？

这个问题要解决可以在这个不可见的类所在的包下在新建一个public类继承这个不可见的类。然后在另外的包中导入这个新建的继承了不可见类的类。通过super点出父类方法。然后实例化对象来调用不可见类的方法。这个问题不要过多的纠结。平常使用不多。

inner class 意思类中类。目前使用不多

3种修饰符 public 公共的 protected 受保护的 private 私有的

java 面对对象特性有：继承 多态 封装 接口

java 提供extends 关键字来实现类之间的继承功能

父类构造方法和子类构造方法的调用顺序
在创建子类对象的时候。会先调用父类的构造方法。然后调用自己的构造方法。

构造方法名与本类名相同。

super关键字直接在子类下点出父类的方法，这种方法不是继承而是直接调用。调用普通方法可以随便 摆放。调用构造方法必须在第一行语句。
这个super方法在使用的时候，如果是调用父类的普通方法需要在子类的普通方法中调用.调用父类的构造方法需要在子类的构造方法中调用 格式如下

调用普通父类方法格式 super.父类方法名（）；

调用父类构造方法格式 super（）；

public benson(){
System.out.println("子类构造方法");
super(56); 不再一行 报错
}

区别在于一个是用.符号点出来来，一个不需要

方法重载和方法重写最大的区别是一个在同一个类，一个是不同类

方法名参数都可以相同

方法重写让子类实现不同的逻辑。自己的特性得到体现
方法名相同 方法名前面的修饰符可以不同
public 公共的 protected 受保护的 private 私有的

修饰符需根据父类的方法修饰符改变并改变比如父类是private 那么子类方法重写就可以变为
public 公共的 protected 受保护的 private 私有的任何一个

反之父类为public 子类只能为public

如果在一个包中有个受保护的方法（注意是受保护不是私有方法。私有方法不可以这样做），而我们又想在另一个包中调用怎么办呢？

那么我们就可以先导入那个包中的类，接着继承这个类。然后通过重写父类的方法。在使用super关键字点出父类的方法。接着就可以实例化对象来调用另外那个包中的方法了。
这是非常巧妙的转变过程。

java多态

根据子类的不同实现不同的功能

父类的引用指向子类的引用对象 这就是多态 一种表现形式之一

子类重写父类方法 创建对象后 队友调用的是重写的父类方法

不要为继承而继承，需要的时候在去加东西。

定义一个动物类，下面有猫科 狗类。昆虫类等子类，通过多态的方式调用各自子类对象的方法。
把方法设为公有，把属性设为私有 。

封装 set意思是 设置 get意思是 获取得到

通过set方法来设置，通过get方法来得到值

POJO类

抽象类天生就是用来继承的。天生就是父类。不来继承就没有意义。关键字abstract

抽象的反义词具体 抽象类不能直接new出对象 必须依靠子类new出对象。通过多态的方式

解耦：不跟某种环境产生关联。

抽象类的定义方法 修饰符 + abstract + class + 类名

抽象类中的方法也叫抽象方法。也需要在修饰符后面加上abstract 比如：public abstract void add();没有大括号表示不想在这里实现方法。而是让继承的子类来实现。

抽象类中可以有抽象方法也可以没有。

多态中，如果你继承的类没有重写所有父类的方法，那么你实例化对象后调用了父类的所有方法就会出现父类的方法在子类实现了。

抽象类自己不实现方法只是定义方法。让继承的子类实现方法。

继承抽象类之后你必须全部实现抽象类中的方法否则就会代码错误。

抽象类中除了有抽象方法后还可以有普遍的实现的方法。
比如：public void test(){
}
一但方法中有一个是抽象方法，那么这个类必须是抽象类。

一个抽象类它可以没有抽象方法。

抽象类中定义了多个抽象方法后可以在定义一个普通方法把这些抽象方法合并到一个方法中
比如：public abstract void a();

public abstract void b();

public abstract void c();

public void d(){
a();
b();
c();
}

这种简化代码的方式称为模版模式也叫模版方法模式。更能发挥抽象类的作用。

流程模版无法改变，具体的实现你才可以改变。

抽象类不能new出对象，但是可以通过父类引用指向子类的对象来new对象。

抽象类其实就是定死流程。有多态的功能。

高层的实现不应该依赖底层，（父类可以替换掉任何子类），具体说就是我们要针对接口抽象来编程，不要针对实现来编程，这样程序才能解耦。

就是子类必须能够完全替代 父类，否则就是不合理的继承关系。

接口

比抽象类更加抽象的结构。抽象类还可以实现自己的方法，接口压根不能实现任何方法。
interface 关键字 可以声明任意多个方法，但是每个方法都没有具体的实现。

接口可以定义很多方法。定义方法不能有{}

java难学的地方在于他的结构变化无穷。接口不能被继承也不能直接使用。

关键字：implements

子类实例化对象。多态也适应这里，父类引用指向子类对象。实例化对象

比如：
一个接口名：
public interface interface_test {
public void a();
public void b();

}

public class Interface_1 implements interface_test{

实现接口的方法。

public static void main(String[] args) {
Interface_1 i=new Interface_1();
i.a();
i.b();

实例化对象。

也可以 interface_test i=new Interface_1(); 多态的写法。

新建一个类。并且建一个静态方法。
public class Interface_3 {
public static void benson(interface_test w){
w.a();
w.b();

这样来调用接口。然后调用接口中的方法、

Interface_1 i=new Interface_1();

Interface_1 j=new Interface_1();
Interface_3.benson(i);
Interface_3.benson(j);

new 出对象来后，这样的使用它的方法。

做一个处理接口的方法才能发挥接口的功效。

一个类可以实现多个接口，变相的让类实现了多重继承一样。

实现多个接口的步骤，首先定义好多个接口。然后新建一个类。

接着实现接口。格式为：public class 类名test implements 接口A ,需要逗号隔开在写下面的接口 接口B{}

接口可以继承接口 接口中定义的属性默认是常量。不能修改。

final 关键字 表示不可变的意思，意思就是定义好的值不能在变化。一般修饰在类，属性和方法上面。

通常使用public final static 来定义一个常量。必须赋值。

final修饰的方法不能被子类重写。

final修饰的类不能被继承。常量名为了区分普通变量最好大写。