面向对象：封装，继承，多态，static

面向对象(一)

基本概念

描述复杂事务，从宏观上整体分析，使用面向对象的思路分析整个系统。具体到微观操作，用面向过程（一步一步做）的思路去处理。

面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据

面向对象三大特性：封装，继承，多态

• 类是一种抽象的数据类型，对某一类事务的整体描述和定义，不能代表一个具体的事物。如Person,Car类。类里面只有成员变量（字段，Field)和方法。类实例化后会返回一个自己的对象

• 对象是抽象概念的具体实例。比如张三是Person类的一个实例。

• 使用new关键字创建对象：会给***对象分配内存空间，并调用类的构造器对对象进行默认初始化***

  • 构造器即构造方法，进行对象创建时必须调用。且必须和类的名字相同，没有返回类型，不能写void。一旦使用有参构造，new 对象只能有参构造，想使用无参构造，必须在类中显式定义无参构造方法。

面向对象特性：封装

• 程序设计追求“高内聚，低耦合”，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

• 封装：（数据的隐藏）：禁止直接访问一个对象中数据的实际表示，通常通过操作接口来访问，即信息的隐藏，简单来讲，就是类属性私有，使用set(),get()方法访问属性

• 封装优势：提高程序安全性，保护数据；隐藏代码实现细节；统一接口；增强系统可维护性

面向对象特性：继承

继承关键字：extends. Java中只有单继承，没有多继承。一个类，只有一个父类，可有多个子类。

• 子类可以继承父类的所有方法和属性
• IDEA 快捷键：Ctrl + h:查看父类。所有类父类直接或间接为Object类

public class Test{
    public void main(String[] args) {
        Student stu = new Student();
        //输出结果：Person无参构造    Student无参构造
        //会默认调用父类的无参构造
        stu.test("张三")
    }
}

class Student extends Person{
    //默认有age属性和say()方法
    private String name = "zhangsan";
    
    public Student() {
        //此处隐藏代码 super();调用了父类的无参构造
        //super();
        System.out.println("Student无参构造");
    }
    public void test(String name) {
        System.out.println(name);//张三
        System.out.println(this.name);//zhangsan
        System.out.println(super.name);//法外狂徒
    }
}
class Person{
    int age;
    public Person(){
        System.out.println("Person无参构造");
    }
    protected String name = "法外狂徒";
    public void say() {
        System.out.println("父亲在说话");
    }
}

• super关键字：

  • 调用父类的成员和方法,调用父类构造方法，super必须放在第一行

  • super只能出现在子类的方法或者构造方法中

  • super和this 不能同时调用构造方法

    this()；本类的构造

    super(); 父类的构造

• 方法重写：需要有继承关系，子类重写父类的方法，重写只和非静态方法有关

  • 1.方法名必须相同
  • 2.参数列表必须相同
  • 3.修饰符：范围可以扩大但不能缩小： public > protected>default>private
  • 4.抛出的异常：范围可以缩小但不能扩大
  • 重写的好处：父类的功能子类不需要（Alt + I)

  puclic class Test {
      public static void main(String[] args) {
          A a = new A();
          a.test(); //A
          a.test1(); //A
          
          //父类的引用指向了子类
          B b = new A(); //b指向的还是A类型开辟的空间
          b.test(); //B
          b.test1();//A
      }
  }
  
  class A extends B{
      putlic static void test() { //static 修饰一开始就随类加载，所以直接调用
          Sysetm.out.println("A");
      }
      
      public void test1() {
          Sysetm.out.println("A");
      }
  }
  
  class B {
      putlic static void test() {
          Sysetm.out.println("B");
      } 
      
      putlic void test1() {
          Sysetm.out.println("B");
      }     
  }
  

面向对象特性：多态

• 多态可以实现动态编译
• 多态即同一方法可以根据发送对象的不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
• 多态存在的条件
  • 有继承关系
  • 子类重写父类方法(static,final,private修饰的方法，子类不能重写)（final修饰的类无法继承）
  • 父类引用指向子类对象
• 多态是方法的多态，属性没有多态性

public class PolymorphismDemo {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的，new Student()
        Student student = new Student();

        //可以指向的引用类型就不确定了：父类引用指向子类
        //Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，不能调用子类独有的方法，只能调用子类重写的方法
        Person s2 = new Student();
        Object s3 = new Student();

        s1.run();
        s2.run();
        //s2.eat();//无法调用
        
        Object obj = new Student();
        System.out.println(obj instanceof Student); //true
        System.out.println(obj instanceof Person); //true
        System.out.println(obj instanceof Object); //true
        System.out.println(obj instanceof Teacher); //false
        System.out.println(obj instanceof String); //false
        //两个类毫无联系时，使用instanceof会报错
        //System.out.println(s1 instanceof Teacher); //编译报错
        
        //强制类型转换： 父 --> 子  高 ---> 低，需要强制类型转换，低-->高：自动转换
		Person p = s1; //自动转换
        Stuendt s = (Student) s2; //强制类型转换
    }
}

class Person {
    public void run() {
        System.out.println("Person.run");
    }
}

class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }

    public void eat() {
        System.out.println("Student.eat");
    }
}

class Teacher extends Person{
    
}

instanceof 关键字：判断一个对象是什么类型

• x instanceof y: x,y存在父子类关系，编译通过

static 关键字

public class StaticDemo {
    private static int age; //静态变量，类变量，所有对象共享此静态变量
    private double score; //非静态变量

    public void run(){
        test();  //非静态方法可以调用静态方法
    }

    public static void test() {

    }

    {
        System.out.println("匿名代码块");
    }
    static {
        System.out.println("静态代码块");
    }
    public StaticDemo(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        StaticDemo s1 = new StaticDemo();//执行顺序：静态代码块-->匿名代码块-->构造方法
        StaticDemo s2 = new StaticDemo();//执行顺序：匿名代码块-->构造方法(静态代代码块只执行一次）
        //通过类名调用静态变量
        System.out.println(StaticDemo.age);
        //通过对象调用成员变量
        System.out.println(s1.age);
        System.out.println(s1.score);

        test(); //一个类里面直接使用静态方法
        StaticDemo.test();//类名.方法名调用
    }
}