Java学习笔记：面向对象（oop）

面向对象即Object Oriented Programming

• 面向过程思想：步骤清晰简单，即第一步做什么，第二步做什么。所以面向过程适合处理一些简单的问题。
• 面向对象思想：是分类的思维模式，会根据待解决的问题思考需要哪些分类，从而调用这些类进行操作，最后对其某个类下的某个方法进行面向过程的使用。所以面向对象更适合处理复杂的需要多人协作的问题。

面向对象编程的本质：以类的方式组织代码，以对象的组织封装数据。
类 = 属性 + 方法
类是抽象的，也可以把类看作一个模板。在做项目时，如果需要使用这个类里的方法，那么需要先实例化这个类，也就是new一个对象，才能利用对象来调用这个类里的方法。

一、对“方法”的补充

1. 方法名：驼峰命名规则，选用见名知意的名字。

2. 可变参数

   1）在指定参数类型后加一个省略号
   2）一个方法中只能定义一个可变参数
   3）可变参数必须是方法的最后一个参数
   

public static void main(String[] args) {
        Print(1,2,3);
    }
    public static void Print(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
    }

3. static：静态，可修饰方法

   1）静态方法：同类一起加载，可在其他类中直接调用  
     	<类名.方法名(参数列表)>
   2）非静态方法：同对象一起加载，必须实例化这个类
   

4. this关键字
   调用此类中的属性或方法。

this.name = "xie";       //属性
this.text();            //方法

二、类与对象

1. 创建对象

• 使用new关键词来创建对象。

创建对象时会在内存中分配空间，并给对象中的属性进行初始化以及调用类中的构造器。

• 初始化
  1）整型、浮点型：0或0.0
  2）字符型：u0000
  3）布尔型：false
  4）引用类型：null
• 对象类型 对象名 = 对象值;

Person  p1 = new Person();  //p1就是Person类的一个实例。

2. 构造器
   与方法同名，并且没有返回值。即使类里面什么都没有，也会自动生成一个无参构造。

public class Person(){
	public Person(){        //无参构造
	}
}

作用： 给实例化赋初始值。
有参构造：定义了有参构造之后，如果要使用无参构造，就必须显化无参构造。
快捷键： Alt + Insert --> Constructor

三、三大特性

1. 封装
   把部分重要数据隐藏，只为用户提供一些接口。可以提高程序的安全性。

• private关键字：私有的

public class Person{ //Person类
private String name; //name的修饰符是private，使用用户不能直接调用name
}                    //私有属性可以让类里的属性更加安全

• get/set 方法
  用户可以使用这两个方法来改变属性的值。
  快捷键： Alt + Insert --> Getter and Setter

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {  //可以在里面加一些判断
        this.name = name;     
    }
}

2. 继承

• extends关键字，使用此关键字可实现继承

public class Person {    //Person类是父类
    
}

public class Student extends Person {  //Student类是子类
//子类会继承父类的全部的方法和属性
//但没有权限访问private修饰的方法和属性
}

• 快捷键：Ctrl + H 可打开继承树
• Object类
  在Java中，所有类会默认直接或间接继承Object类。
• super关键字，使用此关键字可调用父类的属性或方法，使用方法与this关键字相同。
• 方法重写：只有方法能重写，当父类里的方法子类不需要或者不满足时，可以用方法重写。
  前提：
  ①两个类之间是继承关系，且必须是子类重写父类的方法
  ②方法都是非静态和公共的，且不能修饰符不能有final（常量）
  ③方法头都是一致的，只有方法体不同
  快捷键： Alt + Insert --> Override

public class Person {    //父类
    public void test(){
        System.out.println("Hello");
    }
}

public class Student extends Person {  //子类
    @Override  //注解：有功能的注释
    public void test() {
        System.out.println("xie");   //在这里可以重写父类的方法
    }
}

3. 多态
   一个对象的实际类型是确定的，但指向的引用类型可以改变，这就是多态。只有方法才有多态，属性没有，需要有继承关系。

public class Person {    //父类
   
}

public class Student extends Person {  //子类
    
}

public static void main(String[] args) {
        Student student = new Student();
        Person student1 = new Student();
        Object student2 = new Student();
    }

• 子类转向父类：向上转型，直接转换，会丢失子类本身特有的方法

public class Person {    //父类
   
}

public class Student extends Person {  //子类
    
}

public static void main(String[] args) {
        Student student = new Student();
        //子类可以调用自己的方法或父类的方法
        Person student1 = new Student();
        //父类虽然可以指向子类，但不能调用子类特有的方法
        Object student2 = new Student();
    }

• 父类转向子类： 向下转型，需要强制转换，会丢失父类被子类重写的方法

public class Person {    //父类
   
}

public class Student extends Person {  //子类
    public void fun(){
    return;
    }
}

public static void main(String[] args) {
        Person person = new Student();   //父类不能调用子类的特有方法
        ((Student)person).fun();   //强制转换
    }

• instanceof关键字

public class Person {    //父类
   
}

public class Student extends Person {  //子类
    
}

public static void main(String[] args) {
        Person person = new Student();
        System.out.println(person instanceof Student);
 //判断person和Student类是否存在父子关系，是则输出ture，否则输出false
    }