Java初学者笔记十七：面向对象

面向过程和面向对象

面向过程思维
- 步骤清晰简单，第一步做什么，第二部做什么...
- 面向过程适合处理一些较为简单的问题
面向对象思维
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思考。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思维来分析整个系统。具体到围观操作，仍然需要面向过程的思维去处理。

面向对象

面向对象编程（Object-Oriented Programming, OOP）：以类的方式组织代码，以对象的组织（封装）数据。
抽象
三大特性：
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有类。对象是具体的事物，类是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。

类与对象的关系

类是一种抽象的数据类型，它是对某一类事情整体描述/定义，但是并不能代表某一个具体的事物。
对象是抽象概念的具体实例。

创建与初始化对象

使用new关键字创建对象
使用new关键字创建对象的时候，除了分配内存空间以外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

//类:只包括属性和方法。
public class Person {
   
    //属性
   //类是一个模板，不可赋值。
    String name;//未赋值，默认为null。
    int age;//默认为0。
   
    //方法
   public void method(){
       System.out.println(this.name+"MiSuShen");
   }
}

public class Demo01 {
    //一个项目只有一个main方法
    public static void main(String[] args) {
        
        //Person类是抽象的，需要实例化
        //person对象是Person类的具体实例。
        Person person = new Person();//实例化后（new Person();），会返回一个对象。person这个名字随便起。
        
        //同一个类可以产生不同的对象。
        Person person01 = new Person();

        person.name = "弥玊生";
        person.age = 18;

        System.out.println(person.name);//弥玊生
        System.out.println(person.age);//18
    }
}

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
1. 必须和类的名字相同。
2. 必须没有返回类型，也不能写void。

public class Person {
    
    String name;
    //构造器一般用来初始化对象的值

    //无参构造（一个类即使什么也不写，也会存在一个无参构造）
    public Person(){
    }
    
    //有参构造(一旦定义了有参构造，无参构造就必须显示定义)
    public Person(String name){
        this.name = name;
    }
    
}

public class Demo01 {
    public static void main(String[] args) {
        //使用new关键字本质是在调用构造器
        Person person = new Person("弥玊生");//若传了参数，就会调用有参构造器。
        System.out.println(person.name);//弥玊身
    }
}

创建构造快捷键alt+ins

创建对象内存分析简单分析

public class Person{
    public String name;
    public int age;
    
    public void said(){
        System.out.println("Hello");
    }
}

public class Demo01{
    public static void main(String[] args){
            
        Person personOne = new Person();
        personOne.name = "弥玊生"；
        personOne.age = "18";
        personOne.said();
        
        System.out.println(personOne.name);
        System.out.println(personOne.age);
        
        Person personTwo = new Person();
    }
}

面向对象的三大特性

封装

程序设计追求“高内聚，低耦合”。高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装（隐藏的数据）：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
属性私有 get/set
封装的作用：
- 提高程序的安全性，保护数据。
- 隐藏代码的实现细节。
- 统一接口
- 系统可维护性提高

public class Person{
    private String name; //已被私有（private），替换成public则变为公共的。
    private int age;
    
    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    
    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
    
    public int getAge(){
        return age;
    }
    
    // 
    public void setAge(int age){
        if (age < 150 && age > 0){
           this.age = age;
        }else{
           System.out.println("输入超限");
        }
    }
    
    
    //at + ins可自动生成get、set方发
    
}

public class Demo{
    public static void main(String[] args){
        Person person = new Person();
        // (p1.name = )不能直接赋值，已被私有
        
        person.setName("弥玊生");
        System.out.println(person.getName());
        
        person.setAge(18);
        System.out.println(person.getAge());
        
        
    }
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends“拓展”。子类是父类的扩展。
Java中类只有单继承，没有多继承。
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上讲应该具有“is a”的关系。
ctrl + H可查看继承关系
Java中，所有的类，都默认直接或间接继承Object类

public class Father{ //父类    
    public void said(){        
        System.out.println("弥玊生");    
    }
}

public class Son extends Father{  //子类

}

public class Demo{
    public static void main(String[] args){
        
        Son son = new Son();
        son.said(); //弥玊生，若修饰符未private（封装）则不能直接继承（见封装笔记）
    }
}

super

public class Father{
    protected String name = "a";
    
    public void print(){
        System.out.println("Son!")；
    }
}

public class Son extends Father{
     private String name = "b";
    
     public void print(){
        System.out.println("Father!")
    }
        public void test01(String name){
            System.out.println(name); //c
            System.out.println(this.name); //b
            System.out.println(super.name); //a

            public void test02(){
                print(); // Father!
                this.print(); // Father!
                super.print(); // Son!
            }
      }
}

public class Demo{
    public static void main(String[] args){
        
        Son son = new Son();
        son.test01("c")
            son.test02();
    }
}

父类和子类的构造器
- 子类默认调用父类无参构造。
- 调用父类的构造器，必须要在子类构造器的第一行。
- 若父类没有无参构造，子类无参构造可以调用父类有参构造。（要显式调用，否则默认调用无参会报错）
- super和this不能同时调用构造方法。

public class Father{
    public Father(){
      
    }
}

public class Son extends Father{
    public Son(){
         super(); //调用父类的构造器，必须要在子类构造器的第一行。(默认，不用写出)
    }
}

方法重写

方法重写需要有继承关系，子类重写父类的方法。
方法名需相同。
参数列表需相同。
修饰符范围可以扩大，但不能缩小：public > protected > Default > private
抛出异常：范围可以缩小，但不能扩大。
方法重写的作用：父类的功能子类不一定需要或满足。

public class Father{
    public void test(){
        System.out.println("Son!");
    }
}

public class Son extends Father{
    @Override
    public void test(){  // 快捷键ctrl+ins-->Override Methods
        System.out.println("Father!");}

public class Demo{
    public static void main(String[] args){
        Son son = new Son();
        son.test(); //Father!
        
        Father father = new Son(); //子类重写了父类的方法
        father.test(); //Father!
    }
}

若用static静态方法，则不能构成重写。（final,，private也不能重写）

public class Father{
    public static void test(){
        System.out.println("Son!");
    }
}

public class Son extends Father{
    public static void test(){
         System.out.println("Father!");
}

public class Demo{
    public static void main(String[] args){
        Son son = new Son();
        son.test(); //Father!
        
        Father father = new Son(); //父类的引用指向了子类，若用static，方法的调用只和左边定义的数据类型有关。        
        father.test(); //Son！
    }
}

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。（方法的多态，属性没有多态）
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象

public class Father{
     public void method01(){
        System.out.println("Father");
    }
}

public class Son extends Father{
    @Override
    public void method01(){
        System.out.println("Son");
        
        public void method02(){      
            System.out.println("son");
        }
    }
}

public class Demo{
    public static void main(String[] args){
        //对象的实际类型（new Son();）是确定的，但指向的引用类型（Son/Father）有很多种。
        Son p1 = new Son(); //可以调用子类或继承父类的方法。
        Father p2 = new Son(); //父类引用指向子类对象。（不能调用子类独有的方法）
        Object p3 = new Son();
        
        //对象能执行哪些方法，主要看对象左边的类型。
        p1.method01(); //Son
        p2.method01(); //Son，子类重写了父类的方法，执行子类的方法。若子类没有重写则调用父类，Father。        
        //p2.method02();父类没有该方法，不能调用。
        ((Son)p2).method02(); //强制转换
      
      }
}

instanseof

public class Father{
 }

public class Son extends Father{
}

public class GrandSon extends Father{
    }

public class Demo{
    public static void main(String[] args){
        //Object > String
        //Object > Father > Son
        //Object > Father > GrandSon
        
        Object object = new Son();
        System.out.println(object instanceof Son); //Ture
        System.out.println(object instanceof Father); //Ture
        System.out.println(object instanceof Object); //Ture
        System.out.println(object instanceof GrandSon); //False
        System.out.println(object instanceof String); //False
        
        Father father = new Son();
        System.out.println(father instanceof Son); //Ture
        System.out.println(father instanceof Father); //Ture
        System.out.println(father instanceof Object); //Ture
        System.out.println(father instanceof GrandSon); //false
        // System.out.println(father instanceof String); 编译报错 Father类与String类没有父子关系
        
        Son son = new Son();
        System.out.println(Son instanceof Son); //Ture
        System.out.println(Son instanceof Father); //Ture
        System.out.println(Son instanceof Object); //Ture
        // System.out.println(Son instanceof GrandSon); 编译报错
        // System.out.println(Son instanceof String); 编译报错
          
          }
}

类型转换

public class Father{
    public void method01();
    System.out.println("method01");}

public class Son extends Father{
    public void method02();
    System.out.println("method02");}

public class Demo{
    public static void main(String[] args){
        //高转低
        Father obj = new Son(); //只能父类引用指向子类的对象
        ((Son)obj).method02(); //父类转为子类（强制转换，方便方法调用，减少重复代码），Son将这个对象转换为Son类型，就可以使用Son类型的方法
        /*也可写成：
        Son son = (Student) obj;
        son.method02();
        */
        
        //低转高
        Son son = new Son();
        son.method02();
        Father father = son; //子类转为父类，可能丢失一些方法
    }
}