1.初识面向对象

面向过程和面向对象比较

面向过程的思想

​ 步骤清晰简单，第一步做什么，第二部做什么，面向过程适合处理一些较为简单的问题

面向对象的思想

​ 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

总结：

​ 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象

​ 面向对象编程（Object-Orient Programing, OPP）

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

抽象

​ 怎么样理解抽象，举个例子，一个学生管理系统，里面有学生的姓名，学号，班级，身高，体重等等。我们抽取其中的比如说姓名和学号组成一个类。这是一个对抽象形象的解释。

三大特性

封装：把代码里数据封装起来。

继承：子类可以继承父类的东西。

多态：对同一个方法，不同的事物通过这个方法所得出的结果是不一样的。

​ 从认识论的角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

​ 从代码运行的角度考虑是先有类后有对象，类是对象的模板。

1.类与对象

• 类是一种抽象的数据类型，它是对某一类事物整体的描述、定义，但是并不能代表某一具体的事物。例如：植物，动物.....
• 对象是抽象概念的具体实例，例如：仙人掌就是植物的一个具体的实例；狗就是动物的一个实例...

2.方法
定义、调用：！
3.对象的引用
引用类型： 基本类型（8）
对象是通过引用来操作的：栈-->堆

4.属性：字段Field 成员变量
默认初始化：
数字： 0 0.0
char： u0000
boolean： false
引用： null

​ 修饰符 属性类型 属性名 = 属性值！

5对象的创建与使用

• 必须使用new 关键字创造对象， 构造器 new liuyi Person();
• 对象的属性 liuyi.name;
• 对象的方法 liuyi.sleep()

6.类：
静态的属性 属性
动态的行为 方法

2.类与对象的创建

• 使用new关键字创建对象

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

创建一个Student类：

package com.oop.demo02;

//学生类  （一个类里面只有属性和方法两样东西）
public class Student {

    //属性：字段
    String name; //null
    int age;  // 0

    //方法
    public void study(){
        System.out.println(this.name+"学生在学习");
        //this代表当前这个Student类；
    }

}

实例化对象：

public class Application {
    public static void main(String[] args) {

        //类: 抽象的， 实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例

        Student s1 = new Student();
        Student s2 = new Student();

        s1.name = "张三";
        s1.age = 20;

        System.out.println(s1.name);//张三
        System.out.println(s1.age);//20

        s2.name = "李四";
        s2.age = 19;

        System.out.println(s2.name);//李四
        System.out.println(s2.age);//19
    }
}

3、构造器

• 类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。一个类即使什么都不写，他也会存在一个方法，即构造方法（构造器）在IDEA中可以通过ALT+Insert快捷键选择生成构造器；并且构造器有两个特点：

  • 必须和类的名字相同
  • 必须没有返回类型，也不能写void

• 构造器的作用

  • 使用new关键字，本质是在调用构造器
  • 构造器一般用来初始化值

• 一旦定义了有参构造，无参就必须显式定义，这时调用会根据参数来判断是走无参还是有参

4、创建对象内存分析

5、封装

封装重点是对于属性的封装，方法很少用

• 该露的露，该藏的藏

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

• 封装（数据的隐藏）

  • 通常，应该禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

• 属性私有，get/set

写一个学生类：

public class Student{
    //属性私有
    private String name;//名字
    private int id; //学号
    private char sex;    //性别
   
    //提供一些可以操作这些属性的方法
    //提供一些public的get、set方法
    
    //get 获得这个数据
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name=name;
    }
    
}

main方法：

public class Application{
    public static void main(String[] args){
        Student s1=new Student();
        
        s1.setName("张三");
       
        System,out.println(s1.getName());//张三
        //s1.name在这里不能使用了，因为name是private的，如果换成public则可以使用
    }
}

• 封装的意义；
  • 提高程序的安全性，保护数据
  • 隐藏代码的实现细节
  • 统一接口
  • 提高了系统的可维护性

6、继承

• 继承的本质是对某一批类的抽象。（类是对对象的抽象，继承是对类的抽象）
• extends的意思是“扩展”，子类是父类的扩展。
• JAVA中只有单继承，没有多继承。
• 继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
• 子类和父类之间，从意义上讲应该具有“is a”的关系。
• 子类可以继承父类的所有方法（前提是父类的方法是public修饰的）
• 调用父类构造器必须要在子类构造器的第一行。
• 在jiava中，所有的类，都默认直接或间接继承object类

super()注意点：

• super调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法或者构造方法中
• super和this不能同时调用构造方法

VS this:

• 代表的对象不同：

  • this：本身调用者这个对象
  • super：代表父类对象的引用

• 前提：

  • this ：没有继承也可以使用
  • super：只能在继承条件下才可以使用

• 构造方法：

  • this ()：本类的构造
  • super()：父类的构造

7、方法重写

重写都是方法的重写，和属性无关

• 重写：需要有继承关系，子类重写父类的方法！
  1.方法名必须相同
  2.参数列表必须相同
  3.修饰符: 范围可以扩大,但不能缩小 public>Protected>Default>private
  4.抛出的异常：范围可以被缩小，但不能扩大； ClassNotFoundException-->Exception(大)

• 重写：子类的方法和父类必须要一致；方法体不同！

• 为什么需要重写：
  1.父类的功能子类不一定需要，或者不一定满足！
  Alt+Insert：override；

静态方法和非静态方法区别：

• 静态方法：方法的调用只和左边定义的数据类型有关
• 非静态方法：重写

8、多态

• 同一对象可以根据发送对象的不同而采用多种不同的行为方式.

• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

• 多态的存在条件

  • 有继承的关系
  • 子类重写父类的方法
  • 父类引用指向子类对象

• 注意：

  • 多态是方法的多态，属性没有多态
  • 父类和子类，有联系 类型转换异常，ClassCastException
  • 存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father f1 =new Son

• 不能被重写的方法：

  • static 方法，属于类，它不属于实例
  • final 常量：
  • private方法

9、instanceof和类型转换

1.父类引用指向子类的对象
2.把子类转换为父类，向上转型：
3.把父类转换为子类，向下转型，强制转换
4.方便方法的调用，减少重复的代码！

10、static关键字

11、抽象类

• abstract修饰符可以用来修饰方法也可以修饰类，如果i修饰方法，那么方法就是抽象方法；如果修饰类，那么该类就是抽象类。
• 抽象类中可以没有抽象方法，但是抽象方法的类一定要声明为抽象类。
• 抽象类，不能使用new关键字来创建对象，它是用来让子类实现的
• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

12、接口的定义与实现

• 普通类：只有具体实现

• 抽象类：具体实现和规范（抽象方法）都有

• 接口：只有规范 约束和实现分离

• 接口就是规范，定义的一组规则

• 接口的本质是契约，就像人类定义的法规一样，制定好后大家都要遵守。

• OO的精髓，是对对象的抽象，最能体现这一点的就是接口，声明类的关键字是class，声明接口的关键字是interface

• java是单继承的，但是可以通过接口实现多进程

  两个接口：

  package com.oop.demo10;
  
  public interface TimeService {
      void timer();
  }
  

  package com.oop.demo10;
  
  //interface 定义的关键字  ,接口都需要有实现类
  public interface UserService {
  
     //常量~ public static final
     int AGE = 99;
  
     //接口中的所有定义其实都是抽象的 public abstract
      void add(String name);
     void delete(String name);
     void update(String name);
     void query(String name);
  }
  

  接口的实现：

  package com.oop.demo10;
  
  //抽象类 extends
  //类 可以实现接口 implement 接口
  //实现了接口的类，就需要重写接口中的方法
  
  //多继承~利用接口实现多继承
  public class UserServiceImpl implements UserService,TimeService{
      @Override
      public void add(String name) {
  
      }
  
      @Override
      public void delete(String name) {
  
      }
  
      @Override
      public void update(String name) {
  
      }
  
      @Override
      public void query(String name) {
  
      }
  
      @Override
      public void timer() {
  
      }
  }
  

• 接口的作用：

  • 约束

  • 定义一些方法，让不同的人实现

  • 方法都是 public abstract

  • 常量都是常量~ public static final

  • 接口不能被实例化，接口中没有构造方法

  • implements 可以实现多个接口

  • 必须要重写接口中的方法

13、内部类

• 内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对B类来说就是外部类。

• 内部类可分为：

  • 成员内部类

    package com.oop.demo11;
    
    public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
    
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
      }
    }
    

    package com.oop;
    
    import com.oop.demo11.Outer;
    
    public class Application {
        public static void main(String[] args) {
            //new
    
            Outer outer = new Outer();
    
            //通过外部类来实例化内部类
            Outer.Inner inner = outer.new Inner();
            inner.getID();
        }
    
    }
    

  • 静态内部类

  • 局部内部类

    • 写在方法中的类

  • 匿名内部类

    package com.oop.demo11;
    
    public class Test {
        public static void main(String[] args) {
          //没有名字初始化类,不用将实例保存在变量中
            new Apple().eat();
        }
    }
    class Apple{
        public void eat(){
        
        }
    }