05面向对象编程

对象的创建分析

//面向对象编程本质：以类的方式组织代码，以对象的组织(封装)数据 类是一个模板，对象是一个具体的实例
//new 创建对象，还给对象初始化
//一个类什么都不写也会存在一个构造方法
//生成构造器快捷键：alt+insert
public Person(){
}
public Person(string name){//有参构造器
  this.name = name;
}

//创建对象内存分析

面向对象三大特性

• 封装

封装的意义：
1、提高程序的安全性，保护数据
2、隐藏代码的实现细节
3、统一接口
4、提高系统可维护性

• 继承

1、继承是是对某一批类的抽象，从而对现实世界更好的建模
2、Ctrl+H 查看继承树
3、在Java中所有类都默认直接或者间接继承Object类
4、Java中只有单继承，一个子类只能继承一个父类

---

---

super关键字:
1、super调用父类的构造方法，必须在构造方法的第一个；
2、super必须只能出现在子类的方法或构造方法中；
3、super和this不能同时调用构造方法
VS this：
代表的对象不同：
this：本身的对象
super：代表父类对象的应用
前提：
this：没有继承也可以使用
super：只能在继承条件才可以
构造方法：
this():本类的构造
super()：父类的构造

public class Person{
  String name = "Niuniu";
  //父类无参
  public Person(){
  }
  public void print(){
    System.out.println("Person");
  }
  //private void print({System.out.println("Person");} 私有的东西无法被继承
}
public class Student extends Person{
  public Student(){
    super();//隐藏代码：调用了父类的无参构造且必须写在第一行
    System.out.println("Student无参执行了");
  }
  public void test(){
    super.print();//super可调用父类的方法和属性
  }
}
//执行类
public class Application{
  public static void main(String[] args){
    Student student = new Student();
    student.test();//
  }
}

方法重写：
1、子类重写父类方法
2、参数列表必须相同
3、修饰符范围可以扩大，不可缩小：public>protected>default>private
4、抛出的异常：范围可缩小不可扩大
5、alt + insert

public class B{
  public void test(){
    System.out.println("B=>test()");
  }
}
public class A extends B{
  public void test(){
    System.out.println("A=>test()");
  }
  //子类重写父类方法
  @Override
  public void test(){
    System.out.println();
  }
}
public class Application{
  public static void main(String[] args){
    A a = new A();
    a.test();//调用的是A类中的方法
    B b = new A()；//多态
    b.test()；//如果子类未重写父类方法，调用的是B类中的test方法，否则调用的是子类的重写方法
  }
}

• 多态

多态的注意事项：
1、多态是方法的多态，属性没有多态
2、父子类关系才有多态，类型转换异常：classCastException！
3、存在条件：继承，方法需要重写
4、父类引用指向子类对象
5、static(属于类，不属于实例)、final、private方法不可重写

---

---

instanceof(总结不好！)
a instanceof A a与A类是否有关系
强制转换：
1、父类转换子类：向下转型
2、子类转换父类：向上转型

---

---

static静态方法

public class Student{
  //1、static静态代码块,只执行一次
  static{
    System.out.println("静态代码块")；
  }
  //2、赋初值
  {
    System.out.println("静态代码块");
  }
  //3、构造方法
  public Student(){
    System.out.println("构造方法"); 
  }
  private static int age;//静态属性，多线程
  private double score;
  public static void main(String[] args){
    Student s1 = new Student();//输出静态方法、匿名方法、构造器方法
    Student s2 = new Student();//输出匿名方法、构造器方法
    System.out.println(Studnet.age)//静态变量可直接调用
    System.out.println(s1.score);//非静态变量需要实例化才能调用
    
  }
}

抽象类和接口

• 抽象类

抽象类注意点
1、抽象类里能写普通方法和方法体
2、有抽象方法的类必须是抽象类
3、不能new抽象类，只能通过重写子类方法去实现

public abstract class A{
  public abstract void doSomething();//抽象方法，无方法体
  public void say(){
    System.out.println("抽象类可写普通方法");
  }
}
public abstract class B extends A{
  //抽象类继承抽象类无需实现父类的方法
}
//抽象类的所有方法，继承它的子类必须要实现它
public class B extends A{
  @Override
  public void doSomething(){
    System.out.println("实现抽象父类类的方法");
  }
}

//思考题？存在构造器吗？存在的意义？

• 接口

1、接口中所有定义都是抽象的public abstract
2、实现了接口的类要重写接口的所有所有方法
3、类可实现implements多个接口
4、接口里定义的变量是常量
5、接口不能实例化没有构造方法

public interface UserService{
  //常量 public static final
  int AGE = 99；
  void add(String name);
}
public class UserServiceImpl implements UserService{
  @Override
  public void add(String name){
    //接口实现方法
  }
}

内部类及OOP实战

• 内部类

1、成员内部类

public class Outer{
  private int age = 22;
  public void out(){
    System.out.println("这是外部类的方法")；
  }
  //内部类
  public class Inner{
    public void in(){
      System.out.println("这是内部类的方法");
    }
    //获取外部类的私有属性
    public void getAge(){
      System.out.println(age);
    }
  } 
}
//执行类
public class Application{
  public static void main(String[] args){
    Outer outer = new Outer();
    //通过外部类实例化内部类
    outer.Inner inner = outer.new Inner();
    inner.in();//这是内部类的方法
    inner.getAge();//22
  }
}

2、静态内部类

public class Outer{

}
//一个java类中可以有多个class类，但只能有一个public class
class A{

}

3、局部内部类

public class Outer{
  public void method(){
    class Inner{
      public void in(){}
    }
  }
}

4、匿名内部类

public class Test{
  public static void main(String[] args){
    new A().eat();//不用将实例保存在变量中
    UserService userService = new UserService{
      @Override
      public void eat(){}
    }
  }
}
class A{}

interface UserService{
  void eat();
}