Day07----面向对象
面向对象编程
（Java的核心思想就是OOP）
1. 初识面向对象
2. 方法回顾与加深
静态方法可以通过类名.方法名跨类调用，非静态方法只能实例化一个类，也就是新建一个对象去调用public的类
package com.kang.OOP;
//引用传递：对象，本质还是值传递
public class Demo011 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//输出NULL
Demo011.changPersonName(person);//会修改到person这个指针指向的内存中name的区域，所以会修改对象的属性值
System.out.println(person.name);//输出啦啦啦
}
public static void changPersonName(Person person){
person.name="啦啦啦";
}
}
//只能有一个public类
class Person{
String name; //默认为NULL
}
3. 对象的创建分析
注意：
1. **构造器可以理解为C++中的构造函数，分为有参构造和无参构造，如果定义了有参构造但是想使用无参构造会报错，所以默认留下一个无参构造，有参构造的那个相当于方法的重载**
2. 通过`alt+insert`可以快速生成有参和无参的构造器
4. 面向对象三大特性
封装
封装性的意义：1. 提高程序的安全性，保护数据；2. 隐藏代码的实现细节；3. 统一接口，系统可维护性增加
继承
ctrl+H可以快速打开继承树
在Java中都默认继承object类
1. super和this相对，super指向父类，但是私有的东西由于无法被继承所以在子类中使用super也无法调用父类中的私有方法 其他调用如this.name；supr.name
- super()调用父类的构造；调用父类的构造器必须要在子类构造器的第一行，this()调用本类的构造也必须在第一行，所以它们两不能同时用
- 如果父类没有无参构造，子类也无法进行无参构造，所以要写个有参构造，一定要留着一个无参构造
重写必须有继承关系，子类重写父类，方法体不同;只能重写方法，方法名相同，参数也相同;修饰符可以被扩大但是不能被缩小，public>protected>default>private; 抛出的异常的范围可以被缩小但是不能被扩大；
为什么需要重写？父类的功能子类不一定需要或者说子类不一定满足
多态
多态就是同一个接口，使用不同的实例而执行不同操作
static方法属于类的方法不属于对象，final常量，private方法都不能被重写
instanceof：
用于判断一个类是什么类型
instanceof 严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例，用法为：
boolean result = obj instanceof Class
其中 obj 为一个对象，Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果result 都返回 true，否则返回false。
注意：编译器会检查 obj 是否能转换成右边的class类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。看obj和class之间有没有父子关系。
int i = 0;
System.out.println(i instanceof Integer);//编译不通过
System.out.println(i instanceof Object); //编译不通过
instanceof 运算符只能用作对象的判断。
System.out.println( null instanceof Object);``//false
类型转换
- 父类换成子类属于高转低，向下转型，强制转换
- 子类转换成父类，向上转型，可能丢失自己的本来的一些方法，最简单的就是父类的引用指向子类的对象。
package com.kang.OOP;
//一个项目应该只有一个main方法
public class Demo02 {
public static void main(String[] args){
Sub s = new Sub();
System.out.println(s.count);//20
s.display();
Base b = s;
System.out.println(b == s);//true
System.out.println(b.count);//10
b.display();
}
}
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);
}
}
子类继承父类
若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量
static关键字
public class Demo03 {
private static int age; //静态变量 多线程！
private double score;//非静态的变量
public void run(){
}
public static void go(){
}
public static void main(String[] args) {
go();
}
}
public class Demo04 {
//赋初始值
{
System.out.println("匿名代码块"); //代码块（匿名代码块），一般也不建议这样写
}//是在对象创建时初始化
static{
System.out.println("静态代码块");//静态代码块（匿名代码块），一般也不建议这样写
}//类一加载就执行，永久只执行一次
public Demo04() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Demo04 demo04 = new Demo04();
//输出结果：静态代码块、匿名代码块、构造方法
Demo04 demo05 = new Demo04();
//输出结果：匿名代码块、构造方法
}
}
//静态导入包
import static java.lang.Math.PI;
import static java.lang.Math.random;
public class Test {
public static void main(String[] args) {
System.out.println(Math.random());
System.out.println(random());
System.out.println(PI);
//被final修饰的类不能被继承
}
}
5. 抽象类和接口
抽象类
//抽象类
public abstract class Action {
//约束~有人帮我们实现。
//abstract，抽象方法，只有方法名字，没有方法的实现！
public abstract void doSomething();
//1.不能new这个抽象类，只能靠子类去实现宫：约束！
//2.抽象类中可以与普通的方法了
//3.抽象方法必须在抽象类
}
//抽象类的子类都必须实现它的抽象方法，抽象子类可以不用
//java的类是单继承extends，但是接口可以多继承
public class A extends Action{
@Override
public void doSomething() {
}
}
接口
public interface UserService {
//接口中所有定义的方法都默认是public abstract
//接口里定义的常量默认是public static final
int age =99;
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
//类可以通过implements
//实现了接口的类必须实现接口中的方法
public class UserServiceImpl implements UserService{
//鼠标放在爆红的地方，alt+enter
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
}
6. 内部类以及OOP实战
内部类
