小白学Java笔记：面向对象

面向对象三大特征：封装、继承、多态、（抽象）

其实抽象是面向对象程序设计的方法

封装

（提高数据的安全性，保证数据的有效性）
隐藏类的内部信息（实例变量、属性），不允许外部程序直接访问，而是通过方法（赋值方法和取值方法）完成

封装操作步骤

1.在实例变量前添加private，表示私有的，只能在当前类中使用
2.编写对应实例变量的方法（赋值方法和取值方法）Get and Set方法
3.根据情况在赋值方法Set中编写判断语句，保证赋值有效
优化封装：创建set and get方法时，将set方法更改为builder，该方法返回当前对象，赋值时就可以进行连缀操作

继承

（减少代码的冗余性）
当多个类中有相同的属性和方法，可以使用继承完成
1.将多个类中相同的属性和方法组合在一起构成父类
2.编写子类并继承父类，然后在子类中编写独有的属性和方法
父类也叫基类、超类（superclass），子类也叫做派生类subclass

编写步骤

1.编写父类
[修饰符] class 父类类名{
编写属性和方法
}
2.编写子类
[修饰符] class 子类类名 extends 父类类名{
编写独有属性和方法
}
当没有用extends指定继承父类时，系统默认继承Object类，Object类是所有类的父类

重写override

也叫做覆盖override，当父类中的方法不能满足子类的需求，则需要在子类中重写父类的方法

当子类重写父类方法后，创建子类对象调用方法时，调用的是子类重写以后的方法，虽然 父类方法没有使用，但是不能删除，否则子类不能重写
在子类中重写父类的方法，访问权限不能降低，返回类型一致或编写为父类方法返回值类型的子类类型，方法名必须一致，参数列表必须一致
IDEA在子类中重写父类方法用Ctrl + O
子类继承父类，但是不能继承父类的构造方法
创建子类对象时，先执行父类的构造方法（子类中没有用super指定父类构造方法默认调用父类无参构造方法，等价于super();用super指定就执行相匹配的），再执行子类相匹配的构造方法

继承两大特性

1.单继承（单根性）：一个类只能继承一个直接的父类    2.传递性

多态

多种不同的形态（结果）
多个对象调用同一个方法，得到多个不同的结果
语法格式：父类类型 对象名 = new 子类();
当构成多态时，对象名是父类类型，因此只能访问父类中的实例变量和实例方法，但是优先访问子类重写以后的方法
满足多态的条件：1.子类继承父类    2.必须在子类中重写父类的方法        3.父类类型 对象名 = new 子类();
多态的好处：减少代码的冗余性

多态中的两种类型转换

向上转型（自动类型转换）
创建对象时构成多态就是向上转型，由子到父
向下转型（强制类型转换）
当构成多态时，需要访问子类独有的实例变量或实例方法，则必须向下转型，由父到子
向下转型出现类型转换异常：属于运行错误，java.lang.ClassCastException，因为创建对象时当前对象名存放的就是某个对象，只能强转为当前对象类型，不能强转为其他子类类型

instanceof关键字

对象名 instanceof 子类类型   在向下转型之前先进行判断是否是当前对象类型
多态两种使用形式：
1.在方法体中创建子类对象，使用父类作为方法的返回值类型
2.子类对象作为实参，父类对象作为方法形参

static关键字

表示静态，可以修饰属性、方法、代码块、内部类以及实现静态导入

static关键字修饰属性

称为静态变量，也叫类的变量
当类加载到内存时，在方法区给静态变量分配空间存储，一直到程序结束
类中所有对象可以共享静态变量，
访问静态变量：
1.类名.静态变量名        2.对象名.静态变量名
即使对象名的值为null，也可以访问静态变量，因为静态变量当类加载内存时就在方法区存在，一直到程序结束
类优先于对象，生命周期比较长
使用场景：当多个对象中有相同属性时，可以编写为静态变量，只需要在方法区存放一次，节省空间

static关键字修饰方法

称为静态方法，也叫类的方法（main方法就是静态方法）
静态方法中可以使用静态变量和静态方法
实例方法中可以使用静态变量和静态方法，还可以使用实例变量和实例方法。原因：类优先于对象
使用场景：
1.一般工具类中的工具方法编写为静态方法
2.一般方法体中没有使用到实例变量和实例方法时可以编写为静态方法

static关键字修饰代码块

称为静态代码块

作用：完成对静态变量赋值
语法格式：static{    }
当类加载到内存时执行静态代码块，只需执行一次

static关键字修饰内部类

静态内部类
内部类：在类中编写的类称为内部类，也叫嵌套类或内置类
一般内部类是为外部类提供服务的，如果要对其他类提供服务不建议编写成内部类

static关键字实现静态导入

如果要在一个类中直接使用其他类中的静态变量，必须使用静态导入
import static 包名.类名.静态变量名

参数传递

1.基本数据类型作为参数传递

实参传递给形参的是真正的值，相当于复制，传递后的方法中更改变量的值对原方法中变量的值无影响，方法执行完出栈，局部变量也随之释放

2.引用数据类型作为参数传递

实参传递给形参的是地址，也就是实参与形参地址相同，指向同一个对象，当传递后的方法中改变对象属性的值，也就是原方法中属性的值被更改

访问权限

类的访问权限（分为公共类和非公共类）

在类前添加public修饰称为公共类，该类可以在当前包中及其他包中使用
在类前没有public修饰称为非公共类，该类只能在当前包中使用
IDEA编辑器创建类时自动添加public，默认为公共类

成员的访问权限

成员包含成员变量和成员方法

访问权限	在当前类中	在当前包中	在不同包的子类中	在任意包的任意类中
private 私有的	可以使用	不可以使用	不可以使用	不可以使用
默认	可以使用	可以使用	不可以使用	不可以使用
protected 受保护的	可以使用	可以使用	可以使用	不可以使用
public 公共的	可以使用	可以使用	可以使用	可以使用

1.当属性没有要求使用哪个访问权限，建议使用默认的访问权限
2.当要求用封装完成，建议将实例变量编写为private访问权限
3.当要求属性在当前类以及子类中使用，建议编写为protected访问权限
4.大多数情况下，方法使用public访问权限

方法重写也叫覆盖override
1.在子类中重写父类的方法
2.不能缩小访问权限
3.返回值类型一致，或编写父类返回值类型的子类类型
4.方法名称必须一致
5.参数列表必须一致

final关键字

final表示最终的，可以修饰类、属性、方法、局部变量

1.final关键字修饰类

表示该类就是最终的类，不能被继承，常见类：String、System、Scanner......

2.final关键字修饰属性

该属性为常量，存放数据但是不能更改（变量存放数据可以更改）
常量赋值方式有两种：1.在声明时赋值        2.通过构造方法赋值
一般final关键字与static关键字配合使用，也就是静态常量，只需要在方法区开辟一块空间
建议常量名全部大写，多个单词用下划线_隔开

3.final关键字修饰方法

表示该方法不能被重写

4.final关键字修饰局部变量

该局部变量就是常量，值不能被更改

Object类

Object类是所有类的父类，也叫超类，其他类要么直接继承Object类，要么间接继承Object类
如果类没有用extends指定继承父类，系统默认继承Object类
因为类具有传递性，所以所有类都继承Object类中的方法

toString()方法

只输出对象名时，默认调用toString()方法，sout(对象名);等价于sout(对象名.toString());----结果：完整类名@十六进制数
此时先在当前对象的类中找toString()方法，找不到再去父类Object类中找
如果想输出属性值，需要在子类改写父类Object中的toString()方法
第一种方式：Ctrl + O快捷键，手动编写实现功能的代码
第二种方式：Alt + Insert快捷键，选择toString方法，选择实例变量的值重写（常用）

equals(Object obj)方法（返回结果true/false）

两个对象名比较时，比较的是内存地址是否一致，默认在当前类中找equals方法，找不到再去父类Object中找
当要比较两个对象中的属性值是否一致时，父类equals方法不能满足需求，必须在子类中重写
第一种方式：Ctrl + O快捷键，手动编写代码实现
第二种方式：Alt + Insert快捷键，选择equals and hashCode()，自动生成代码

抽象类和抽象方法

抽象类：一般将父类编写为抽象类，使用abstract关键字
抽象类不能创建对象（不能new或者实例化）,抽象类也是多态的一种形式
抽象方法：当父类中方法的方法体在子类中用不到时，可以编写为抽象方法，加abstract关键字
抽象方法必须没有方法体，大括号不需要编写，直接以英文分号;结尾
抽象方法必须编写在抽象类中
子类继承抽象类时，必须重写抽象类中所有抽象方法，否则子类也是抽象类

接口

抽象类中只有抽象方法时，可以编写为接口
接口使用interface关键字，接口中所有方法默认有public abstract
public interface 接口名{
void 方法名;
}
类与类之间是继承，子类继承父类，并且是单继承
接口与接口之间是继承，子接口继承父接口，并且是多继承
类与接口之间是实现implements，也就是实现类，实现接口，并且是多实现，之间用英文逗号隔开
接口不能继承类
既有继承又有实现时，继承必须位于实现的前面，否则出现编译错误
实现类实现接口时，必须重写接口中所有的抽象方法，否则实现类也是抽象类
接口也是多态的一种形式，不能创建对象
接口是对功能的封装，一个接口封装一个功能 
在JDK8.0中，接口中可以包含抽象方法（默认有public abstract）、公有静态变量（默认有public static final）、public static修饰的方法、public default修饰的方法

抽象类和接口异同点

相同点
1.抽象类和接口都不能创建对象，都是多态的一种形式
2.子类继承父类时，实现类实现接口时，都必须重写抽象类或接口中所有的抽象方法，否则子类/实现类也是抽象类
不同点
抽象类使用abstract关键字，接口使用interface关键字
抽象类中可以编写普通类中包含的所有内容，还可以包含抽象方法，在JDK8.0中，接口可以包含抽象方法（默认有public abstract）、公有静态常量（默认有public static final）、public static修饰的方法、public default修饰的方法
子类继承父类，并且是单继承。实现类实现接口，并且是多实现

内部类

在类中编写的类称为内部类，也叫嵌套类或内置类
当大的数据结构包含若干个小的数据结构，可以将这些小的数据结构编写为内部类
一般内部类是对外部类提供服务的，如果还想对其他类提供服务，不建议编写为内部类

内部类分类

成员内部类：在类中直接编写的类，一般在外部类的实例方法中使用
静态内部类：在类中编写并添加static关键字修饰，一般在外部类的静态方法中使用
局部内部类：在方法中编写的类
匿名内部类：也就是没有名字的类，当只创建一次对象时，则可以使用匿名内部类完成

类与类之间的关系

UML：统一建模语言
常用的：类图、用例图、时序图......
画图工具：StarUML、Visio......
继承（泛化）：子类继承父类，子接口继承父接口
实现：实现类实现接口
依赖：如果A类方法的返回值类型、参数列表、局部变量使用到了B类，就称A类依赖于B类
关联：如果A类中使用B类定义了成员变量，就称A类关联B类
聚合：聚合是关联的一种，如果A类中包含若干个B类，但是A类不能限定B类的生命周期，则称为A类为聚合类
组合：组合是关联的一种，如果A类中包含若干个B类，但是A类能限定B类的生命周期，则称为A类为组合类

递归

方法自己调用自己，一般都要保证有出口，否则就成了死循环。比如计算阶乘