面向对象

一.什么是面向对象？

• 面向对象编程（Object-Oriented programming )简称OOP。

• 面向对象的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

• 万物皆对象

• 对象=属性+方法

• 开发过程先有类后有对象，分析过程先有对象后有类。

对象的含义是指具体的某一个事物，即在现实生活中能够看得见摸得着的事物。在面向对象程序设计中，对象所指的是计算机系统中的某一个成分。在面向对象程序设计中，对象包含两个含义，其中一个是数据，另外一个是动作。对象则是数据和动作的结合体

二.面向对象的三大特性

1. 封装

封装的思想：

• 高内聚，底耦合。

• 高内聚:类的内部数据操作细节自己完成，不让外面干预。

• 底耦合:尽量暴露少量的方法给外部使用。

• 私有属性，公开方法。

访问权限修饰符：

修饰符	含义	作用
public	公共的	任何类都可以访问
protected	受保护的	同包类或该类的子类
default	默认的	同包类可以访问
private	私有的	本类中才可以访问

private实现封装：（封装属性防止有调用者对其进行修改，公开方法给调用者使用）

public class Student{
    private String name;
    private int age;
    
    //外部类通过调用get和set方法来操控属性
    public String getName(){
        return this.name;
    }
    
    public void setNmae(String name){
        this.name = name;
    }
}

封装的意义：

1. 对调用者隐藏不需要的操作，调用者只能使用该使用的方法。
2. 调用者无法自由修改属性，保护了数据的安全性。

2. 继承

继承关系的两个类，一个为子类（派生类）一个叫父类（基类）
继承是类和类的一种关系。类和类之间的关系还有依赖，组合，聚和。

继承的意义：

1. 功能（业务）的扩展。
2. 代码的重复使用

extends实现继承

public class 子类 extends 父类{
}

• 子类会继承父类的public的属性和方法，私有的无法被继承

• Java中类只有单继承，没有多继承。一个子类只能继承一个父类，一个父类可以有多个子类

super()关键字:

    - super：调用父类的构造

1. super调用父类的构造方法，必须写在构造方法的第一个。

2. super必须只能出现在子类的方法或者构造方法中！

3. super和this不能同时调用构造方法。

4. super只有在继承里可以使用

5. this没有继承也可以使用

//子类（学生类）
public class Student extends Person{
    private String name = "yujia";
    
     //无参构造方法
     public Student(){
         //调用默认构造方法
         //隐藏super();---------->在new调用学生类时，**会先调用父类的构造方法,super必须在第一行**
         System.out.println("Student无参执行了");
     }
   
    public void text(String name){
           System.out.println(name);
            System.out.println(this.name);
            System.out.println(super.name);
    }
}

//父类（人)
public class Person{
    
    public Person(){
        
    }
    
    protected String name = "jialaing";
}

public class Super{
    public static void main(String[] args){
        
        Student student = new Student("那是地方");-----------------------------在new调用学生类时
        student.text();
    }
}

this关键字：

• this：调用本类的构造

• this关键字必须放到非静态方法里

• 使用this关键字在自身构造方法内部引用其他构造方法

• 使用this关键字代表自身类的对象

• 直接使用this代表自身类的对象

• 使用this关键字引用成员变量,引用成员方法

public class Baa{
    int a;
    public Baa(){
      this(0)
    } 
    public Baa(int a){
      this.a = a;
    }
}

继承子类构造器中隐藏的super():

子类的默认无参构造方法，会在第一行有一段隐藏代码super()默认调用父类的构造器。如果显示的写出必须要在构造方法中的第一行。在创建子类对象时默认构造默认调用父类的构造。

1. super() 父类的成员变量
2. super() 父类的成员方法
3. super() 调用父类的构造方法
   super和this不能在静态方法中使用
   
   显示的加了super()，在传进去 一个父类构造的参就不报错了
   
   

最后总结：在继承过程中父类可以没有默认构造只要使用了super(参)的方式，子类如果写了默认构造那父类必须写默认构造，父类写了默认构造，子类可以不写。

Java中Object类：

• 在IDEA中可以通过ctrl+H的方法查看
• 在java中所有的类都默认继承Object类。
  

final关键字：

• 修饰属性在定义时初始化或在构造方法中一但被定义就无法更改

• 方法：定义必须有实现方法，并且子类里不可被覆盖（重写）

• 类：不能被定义成抽象类和接口，不能被继承

• 对参数加修饰，就无法在方法中修改。

建议使用继承时不要超过三层，给最后一层加上final修饰。

组合：

组合也是一种表达类之间关系的方式，也可以达到代码重用的效果。

public class Student{
}
public class Teacher{
}
public class School{
	public Student[] students;
	public Teacher[] teachers;
}

方法重写：

• 重写是继承中的，子类重写父类的方法，方法名必须相同。

• 修饰符：范围可以扩大但不能缩小。

• 抛出异常：范围，可以被缩小但不能扩大；classNotfoundExeption →Exception（大）

• 必须是public的方法

• 必须是非静态的方法

• 静态方法：方法的调用只何左边有关。在继承中 B b = new A();

Class A{
  public void add(){
  
  }
}
Class B extends A{
  public void add(){
  //重写覆盖A类的方法
  }
} 

//多态的前提：在继承关系方法重写
Class C{
    A asd = new B();
    
    asd.add();
} 

3. 多态

多态的三个前提：

1. 必须是继承关系
2. 子类重写父类的方法
3. 父类引用指向子类对象

即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

向上转型：

1. 直接赋值

//说白了就是父类引用指向子类对象。
父类 对象 = new 子类();

向上转型了就可以使用父类中的对象，和子类中重写父类的方法，除了被重写的父类方法就无法使用了。

2. 方法传参

public static void funct(父类 参){}
Cat cat = new Cat();
funct(cat);

3. 方法返回

public static 父类 funct(){
	创建子类对象
	return 子类对象;
}
父类 对象 = funct();

向下转型：

父类 对象 = new 子类();

子类 A对象 = （子类）父类对象;
//这时这个A对象就可以使用子类中独有的方法

向下转型一般不建议用，因为非常的不安全。

推荐使用instanceof

if(向上转型对象 instanceof 子类){
	子类 子类对象 = (子类）向上转型对象；
}

注意：向上转型的对象，本身就是子类引用，当然可以强行转换为子类。如果类型不一致，就会报类型转换异常

动态绑定（运行时绑定）

先向上转型
通过父类引用来调用子类重写父类的方法。
动态绑定叫运行时绑定，因为程序在编译的时候调用的其实是父类的方法，但程序在运行时调用的是子类的方法，运行时发生了动态绑定。

方法重写（@Override）

方法重写的条件

1. 方法名相同
2. 方法的参数列表相同（返回类型和数据类型）
3. 方法的返回值相同

返回值构成 的 父子关系也可以发生重写（协变类型）

方法重写的注意点：

• 子类重写的方法，访问修饰符，一定要大于父类方法或等于。
• 被final和static修饰的方法无法被重写。

三.类的结构

• 属性：变量

• 方法：对象的行为；

• 构造方法：用于实例化对象；

• 块：分为静态块，实例块

• 内部类：（inner class）即在类体中声明的类

//类如同：人类
//对象：张三
//属性：张三的名字，张三的年龄，本质其实就是变量
//方法：张三的行为，如会跑，会跳

public class people{
  public static void main(String[] args){
    String Name = "张三";
    int age = 20; 
  }
}

//[访问权限修饰符][修饰符]class 类名
//public/default(什么都不写就是) [final/synchronized/abstract]
public class Person{
  //属性:[访问权限修饰符][修饰符][数据类型] 属性名;
  private String name;
  private double salary;
  private static int count = 0;
  
  //方法:[访问权限修饰符][修饰符]返回值数据类型方法名(形参){return 返回值}
  public String getAccountId(){
    return  nane;
  }
  
  //修改密码
  void setPwd(String newPwd){
    pwd=newPwd;
  }
}

四.构造方法(构造器)

• 构造方法名和类名一至

• 没有返回值，连void都没有

• **构造方法用处？**用来创建对象。

• 使用new关键字，本质是在调用构造器。

• 一但定义的有参构造方法，默认构造器就会被去掉。

• 初始化值
  默认构造方法（构造器）

                 //    默认构造方法
public class Tow{
     public Tow(){
        // 在IDEA中打开out输出文件中的Class文件查看就会看到默认构造方法。
     }
}

创建构造方法

public class Two{
  private String color;
  //构造方法
  //[访问权限修饰符] 类名 （形式参数列表) {方法体}
  public Two(String color){
    this.color = color;
    //加上this关键字区分属性和参数
  }
}

public class Dome{
      //   构造器会初始化String为空 ,int为0
     
      String name;
      int age;
      
      public One(){}
      
      //   初始化值，因为不能在类中的属性初始化
      public One(String name){
          this.name = name;
      }
}