面向过程&面向对象

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

属性+方法构成类

什么是面向对象

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

package pers.oop.demo01;

public class Demo02 {

    public static void main(String[] args) {
        //实例化这个类 new
        //new Student().say();
        //对象类型  对象名 = 对象值;
        Student student = new Student();
        student.say();
    }
    
    //static是和类一起加载的
    public static void a(){
        //b();
        
    }
    //类实例化之后才存在
    public void b(){
        
    }
}

package pers.oop.demo01;

public class Demo03 {
    public static void main(String[] args) {
        //实际参数和形式参数一一对应
        new Demo03().add(1,2);
    }

    public int add(int a,int b){
        return a+b;
    }
}

package pers.oop.demo01;

//值传递
public class Demo04 {
    public static void main(String[] args) {
        int a =1;
        System.out.println(a);
        change(a);
        System.out.println(a);
    }

    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

package pers.oop.demo01;

//引用传递，对象，本质还是值传递
//对象，内存！
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);

        Demo05.change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        //person是一个对象，指向的--->Person person = new Person();这是一个具体的人，可以改变属性
        person.name = "张三";
    }
}


//定义了一个person类，有一个属性name
class Person{
    String name;
}

类和对象的关系

• 类是一种抽象的数据类型，它是对某一类失误整体描述/定义，但是并不能代表某一个具体的事物。
  • 动物、植物、手机、电脑……
  • Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
• 对象是抽象概念的具体实例
  • 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
  • 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建与初始化对象

• 使用new关键字创建对象
• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
• 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点：
  • 1.必须和类的名字相同
  • 2.必须没有返回类型，也不能写void
• 构造器必须掌握

  package pers.oop.demo02;
  
  //java ---> class
  public class Person {
      //一个类即使什么都不写，它也会存在一个方法
      //显示的定义构造器
      String name;
      //实例化默认的初始值
      //1.使用new关键字，必须要有构造器，本质是在调用构造器
      //2.用来初始化值
      public Person(){
          this.name = "张三";
      }
  
      //有参构造，一旦定义了有参构造，无参就必须显示定义（即有参必须搭配无参）
      //子类继承父类的时候会自动继承父类的默认构造函数（也就是继承那个无参数的构造函数）。
      /*无参构造函数是所有构成函数的父类，如果没有写那个默认的不带参数的构造函数的话，继承的时候子类就会报错，
      因为系统不知道要不继承哪个构造函数，必须明确的使用super（）关键字来描述。所以一般为了避免这种错误的发生，
      在有带有多个构造函数的类里面都会写一个不带参数的构造函数。*/
      public Person(String name){
          this.name = "张三";
      }
  
      //alt + insert   选择Constructor 可以自动构造构造器
      
      
  }
  
  
  /*
      public static void main(String[] args) {
          //实例化了一个对象
          Person person = new Person();
          System.out.println(person.name);
      }
      
      构造器，
          1.和类名相同
          2.没有返回值
       作用：
          1.new本质是在调用构造器
          2.初始化对象的值
       注意点：
          1.定义了有参构造之后，如果要使用无参构造，必须显示的定义一个无参构造
   */
  

一个项目建议只存在一个main方法
mian方法位于栈

package pers.oop.demo03;

public class Application {
    //mian方法位于栈
    public static void main(String[] args) {
        //dog方法在栈里是一个引用变量名，实际对象在堆里，栈里的变量地址指向堆
        Pet dog = new Pet();
        dog.name = "旺财";
        dog.age = 3;
        dog.shout();

        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

//静态方法区，一开始和类一起加载，所有对象都能够直接调用

package pers.oop.demo03;

public class Pet {
    String name;
    int age;
    //无参构造
    public void shout(){
        System.out.println("叫了一声");
    }
}

总结

package pers.oop;

public class Application {
    /*
    1.类与对象
        类是一个模板：抽象，对象是一个具体的实例
    2.方法
        定义，调用
    3.对象的引用
        引用类型：  基本类型（8个）
        对象是通过引用来操作的，引用是对象的一个地址，最终都从栈指向堆
    4.属性：字段fioeld 成员变量
        默认初始化
            数字：0  0.0
            char：u0000
            boolean：false
            引用：null
        修饰符  属性类型  属性名 = 属性值！
    5.对象的创建和使用
        - 必须使用new关键字创造对象 Person zhangsan = new Person();
        - 对象的属性 zhangsan.name
        - 对象的方法 张三.sleep()
    6.类：
        静态的属性   属性
        动态的行为   方法
        
    封装、继承、多态
     */
}

封装

• 该露的露，该藏的藏
  • 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合，仅暴露少量的方法给外部使用。
• 封装（数据的隐藏）
  • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
• 记住这句话：属性私有，get/set

  package pers.oop;
  
  import pers.oop.demo04.Student;
  
  /*
  1.提高程序的安全性，保护数据
  2.隐藏代码的实现细节
  3.统一接口
  4.提高系统的可维护性
   */
  public class Application {
      public static void main(String[] args) {
          Student s1 = new Student();
          s1.setName("张三");
          System.out.println(s1.getName());
  
          s1.setAge(999);//不合法的
          System.out.println(s1.getAge());
  
      }
  }
  

  package pers.oop.demo04;
  
  //类 private:私有
  public class Student {
  
      //属性私有
      private String name;//名字
      private int id;//学号
      private char sex;//性别
      private int age;
      //性别
  
      //学习()
      //睡觉()
  
      //提供一些可以操作这个属性的方法！
      //提供一些public的get、set方法
      //get 获得这个数据
      public String getName(){
          return this.name;
      }
      //set 给这个数据设置值
      public void setName(String name){
          this.name = name;
      }
  
      //alt + insert 选择Getter and Setter  自动生成属性
  
  
      public int getAge() {
          return age;
      }
  
      public void setAge(int age) {
          if (age<120 && age>0){
              this.age = age;
          }else{
              this.age=3;
          }
  
      }
  }
  

继承

• 继承的本质是对某一批类的抽象，从而实现对显示世界更好的建模。

• extands的意思是“扩展”，子类是父类的扩展

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

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

• 继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示

• 子类和父类之间，从意义上讲应该具有“is a”的关系

• object类

  package pers.oop;
  
  import pers.oop.demo05.Person;
  import pers.oop.demo05.Student;
  
  public class Application {
  
      public static void main(String[] args) {
          Person person = new Person();
      }
  }
  
  

  package pers.oop.demo05;
  
  //Java中,所有的类，都默认直接或者间接继承object类
  //Person 人： 父类
  public class Person {
  
      //public  子类可以继承
      //protected
      //default
      //private 父类的私有子类无法继承
      private int money = 10_0000_0000;
      public void say(){
          System.out.println("说了一句话");
      }
  
      public int getMoney() {
          return money;
      }
  
      public void setMoney(int money) {
          this.money = money;
      }
  }
  

  package pers.oop.demo05;
  
  //学生 is 人 派生类 子类
  //子类继承了父类，就会拥有父类的全部方法
  public class Student extends Person{
      //Ctrl+h   查看类继承树
  }
  

  package pers.oop.demo05;
  
  //Teacher is 人 派生类 子类
  public class Teacher extends Person{
  }
  

• super

  package pers.oop;
  
  import pers.oop.demo05.Person;
  import pers.oop.demo05.Student;
  
  public class Application {
  
      public static void main(String[] args) {
  //        Student student = new Student();
  //        student.test1();
          Student student = new Student();
      }
  }
  
  

  package pers.oop.demo05;
  
  //学生 is 人 派生类 子类
  //子类继承了父类，就会拥有父类的全部方法
  public class Student extends Person{
      public Student() {
          //隐藏代码：默认调用了父类的无参构造
          super();//调用父类的构造器必须在子类构造器的第一行
          //调用自身构造器也必须在第一行,所以this和super无法同时
          //this();
          System.out.println("Student无参执行了");
      }
  
  
      private String name = "lisi";
  
      public void print(){
          System.out.println("Student");
      }
  
      public void test1(){
          print();
          this.print();
          super.print();
          //super无法调用私有方法及属性，私有无法被继承
          //super.print1();
      }
      public void test(String name){
          System.out.println(name);  //参数
          System.out.println(this.name); //自有
          System.out.println(super.name); //父类
      }
  }
  
  

  package pers.oop.demo05;
  
  //Java中,所有的类，都默认直接或者间接继承object类
  //Person 人： 父类
  public class Person {
      public Person() {
          System.out.println("Person无参执行了");
      }
  
      protected String name = "zhangsan";
      public void print(){
          System.out.println("Person");
      }
  
      private void print1(){
          System.out.println("Person");
      }
  }
  
  

  • super注意点
    1. super调用父类的构造方法，必须在构造方法的第一个
    2. super必须只能出现在子类的方法或者构造方法中！
    3. super和this不能同时调用构造方法！
  • VS this
    • 代表的对象不同
      • this：本身调用者这个对象
      • super：代表父类对象的应用
    • 前提
      • this：没有继承也可以使用
      • super：只能在继承条件下才可以使用
    • 构造方法
      this()：本类的构造
      super():父类的构造！

• 方法重写

  package pers.oop;
  
  
  import pers.oop.demo05.A;
  import pers.oop.demo05.B;
  
  public class Application {
      
      //静态方法和非静态的方法区别很大！
          //静态方法：//方法的调用只和左边定义的数据类型有关//父类的引用指向了子类
          //非静态的方法：//子类重写了父类的方法--->重写，重写的关键词只能是public
      public static void main(String[] args) {
          
          A a = new A();
          a.test();//A
          
          B b = new A();
          b.test();//B
      }
  }
  
  

  package pers.oop.demo05;
  
  //继承
  public class A extends B{
      //Alt + insert  ---> overrride
  
  //    public  void test(){
  //        System.out.println("A>+test()");
  //    }
  
      @Override //注解：有功能的注释
      public void test() {
          //super.test();
          System.out.println("A>+test()");
      }
  }
  
  

  package pers.oop.demo05;
  
  //重写都是方法的重写，和属性无关
  public class B {
      public  void test(){
          System.out.println("B>+test()");
      }
  }
  
  

  • 重写需要有继承关系，而且是子类重写父类的方法！
    1. 方法名必须相同
    2. 参数列表也必须相同
    3. 修饰符，范围可以扩大：private可以变public，但不能从public变private。关系：public > protected >default > private
    4. 重写的异常：范围可以被缩小，但是不能扩大。 ClassNotFoundException <-- Exception(大)
  • 重写子类的方法和父类必须与一致，但方法体不同
  • 重写的必要性
    1. 父类的功能，子类不一定需要，或者不一定满足！
       Alt + Insert ---> override

多态

• 动态编译：类型：可扩展性

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

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

• 多态存在的条件

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

• 注意：多态是方法的多态，属性没有多态性

  package pers.oop;
  
  
  import javafx.beans.binding.ObjectExpression;
  import pers.oop.demo06.Person;
  import pers.oop.demo06.Student;
  
  public class Application {
  
      public static void main(String[] args) {
          //一个对象的实际类型是确定的
          //new Student();
          //new Person();
  
          //可以指向的引用类型就不确定了
          Student s1 = new Student();//student恩能够调用的方法都是自己的或者继承父类的
          //父类的引用指向子类的类型，可以通过父类来new子类
          //Person 父类型，可以指向子类，但是不能调用子类独有的方法
          Person s2 = new Student();
          Object s3 = new Student();
  
          s2.run();//子类重写了父类的方法，执行的就是子类的方法
          s1.eat();//运行的时候才知道用那个方法
          //s2.eat() // s2的类型是Person类，里面没有eat方法
          ((Student) s2).eat();//强制转换，高转低
          //对象能执行哪些方法主要看对象左边的类型和右边的关系
      }
  }
  
  

  package pers.oop.demo06;
  
  public class Student extends Person{
      @Override
      public void run() {
          System.out.println("son");
      }
  
      public void eat(){
          System.out.println("eat");
      }
  }
  
  

  package pers.oop.demo06;
  
  public class Person {
      public void run(){
          System.out.println("run");
      }
  }
  
  

• 多态注意事项

  1. 多态是方法的多态，属性没有多态
  2. 父类和子类，有联系，类型转换异常！ ClassCastException！
  3. 存在条件，继承关系，方法需要重写，父类引用指向子类对象
  4. static方法属于类，不属于实例，无法重写
  5. final修饰的是在常量池里的，无法重写
  6. private方法无法重写

• instanceof （类型转换） 引用类型，判断一个对象是什么类型

  package pers.oop;
  
  import pers.oop.demo06.Student;
  import pers.oop.demo06.Person;
  
  public class Application {
      public static void main(String[] args) {
          //类型之间的转化  基本类型转换  父 子
          //高              低
          //子类转化为父类可能丢失一些方法
          Person obj = new Student();
          //obj将这个对象转换为student类型，我们就可以使用student类型的方法了！
  //        Student student = (Student) obj; //强制转换
  //        student.go();
          ((Student)obj).go();  //强制转换
  
  
      }
  }
  
  

  package pers.oop.demo06;
  
  public class Person {
      public void run(){
          System.out.println("run");
      }
  }
  

  package pers.oop.demo06;
  
  public class Student extends Person{
      public void go(){
          System.out.println("go");
      }
  }
  
  
  /*
  public static void main(String[] args) {
          //Object > String
          //Object > Person > Teacher
          //Object > Person > Student
          Object object = new Student();
  
          //System.out.println(x instanceof y);  //能不能编译通过！ 接口
          System.out.println(object instanceof Student); //true
          System.out.println(object instanceof Person);  //true
          System.out.println(object instanceof Object);  //true
          System.out.println(object instanceof Teacher);  //false
          System.out.println(object instanceof String);  //false
          System.out.println("++++++++++++++++++++++++++");
          Person person = new Student();
          System.out.println(person instanceof Student); //true
          System.out.println(person instanceof Person);  //true
          System.out.println(person instanceof Object);  //true
          System.out.println(person instanceof Teacher);  //false
          //System.out.println(person instanceof String);  //编译错误
          System.out.println("++++++++++++++++++++++++++++++");
          Student student = new Student();
          System.out.println(student instanceof Student); //true
          System.out.println(student instanceof Person);  //true
          System.out.println(student instanceof Object);  //true
          //System.out.println(student instanceof Teacher);  //编译错误
      }
   */
  

  package pers.oop.demo06;
  
  public class Teacher extends Person{
  
  }
  

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

Static关键字详解

通过final修饰的类就没有子类了，不能被继承

package pers.oop.demo07;

//Static :
public class Student {

    private static  int age;  //静态的变量   多线程！
    private double score;  //非静态变量

    public void run(){

    }
    public static void go(){

    }

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);   //静态变量建议用类名直接访问
        System.out.println(s1.age);
        System.out.println(s1.score);
        Student.go();
        go();

    }
}

package pers.oop.demo07;

public class Person {
    {
        //代码快（匿名代码块）
    }
    static{
        //静态代码块，加载一些初始化的数据
    }

    //===========================================
    //2
    {
        //可以用来赋一些初始值
        System.out.println("匿名代码块");
    }
    //1
    static {
        System.out.println("静态代码块");
    }
    //3
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        //static只执行一次
        Person person1 = new Person();
        System.out.println("=============");
        Person person2 = new Person();
    }
}

package pers.oop.demo07;

//静态导入包
import static java.lang.Math.random;

public class Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(Math.PI);
    }
}

抽象类

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

  package pers.oop.demo08;
  
  //abstract 抽象类  类  extends：单继承  java没有多继承方法  但是接口可以多继承
  public abstract class Action {
      //约束~有人帮忙实现
      //abstract，抽象方法，只有方法名字，没有方法的实现！
      public abstract void doSomething();
      
      //1. 不能new这个抽象类，只能靠子类去实现它：约束！
      //2. 抽象类中可以写普通方法
      //3. 抽象的方法必须在抽象类中
      //抽象的抽象：约束
      
      //思考  抽象类不能new，是否存在构造器  --可以有构造器
      //抽象类存在的意义   抽象出来~提高开发效率
  }
  

  package pers.oop.demo08;
  
  //抽象类的所有方法，继承了它的子类，都必须要实现它的方法~ 除非~
  public class A extends Action{
      //必须重写抽象方法
      @Override
      public void doSomething() {
  
      }
  }
  
  

接口

• 普通类：只有具体实现

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

• 接口：只有规范！自己无法写方法~专业的约束！约束和实现的分离：面向接口编程

• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是……则必须能……”的思想，如果你是天使，则必须会飞。如果你是汽车，则必须能跑。如果你是好人，则必须干掉坏人。如果你是坏人，则必须欺负好人。

• 接口的本质是契约，就像我们人间的法律一样，指定好后大家都遵守

• OO（面向对象）的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计，模式都只针对具备了抽象能力的语言（比如C++、java、C#等），就是因为设计模式所研究的，时间上就是如何合理的去抽象
  声明类型的关键字是class，声明接口的关键字是interface

  package pers.oop.demo09;
  
  //抽象的思维~ java  架构师
  //interface定义关键字，接口都需要实现类
  public interface UserService {
  
      //属性~常量  public static final
      int age =99;
  
      //接口中的所有定义的方法其实都是抽象的 public abstract
      void add(String name);//public abstract void add();
      void delete(String name);
      void update(String name);
      void query(String name);
  
  }
  

  package pers.oop.demo09;
  
  public interface TimeService {
      void timer();
  }
  
  

  package pers.oop.demo09;
  
  //抽象类：extends~单继承
  //类  可以实现接口，implements接口
  //实现了接口的类，就需要实现接口的方法
  
  //多继承~利用接口实现伪多继承
  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() {
  
      }
  }
  
  

• 作用：

  1. 约束
  2. 定义一些方法，让不同的人实现~ 10 ---> 1
  3. public abstract
  4. public static final
  5. 接口不能被实例化，接口中没有构造方法
  6. implements可以实现多个接口
  7. 必须要重写接口中的方法~

内部类

• 内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就成为内部类，而A类相对B类来说就是外部类了
• 1.成员内部类
• 2.静态内部类
• 3.局部内部类
• 4.匿名内部类

  package pers.oop.demo10;
  
  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);
          }
      }
          
      //静态内部类
      public static class Inner1{
          public void in(){
              System.out.println("这是内部类的方法");
          }
  
          //获得外部类的私有属性
          public void getId(){
              //static类先实例化，所以id失效了
              //System.out.println(id);
          }
      }
      
      //======================================
      //局部内部类
      public void method(){
          class Inner{
              public void in(){
                  
              }
          }
      }
  }
  
  //内部类
  //一个java class里只能有一个public class，但是可以有多个class类
  class A{
      public static void main(String[] args) {
          
      }
  }
  

  package pers.oop;
  
  
  import pers.oop.demo10.Outer;
  
  public class Application {
      public static void main(String[] args) {
          //new
          Outer outer = new Outer();
          //通过这个外部类来实例化这个内部类
          //成员内部类
          Outer.Inner inner = outer.new Inner();
          inner.in();
          inner.getId();
      }
  
  }
  
  

  package pers.oop.demo10;
  
  public class Test {
      public static void main(String[] args) {
          //没有名字初始化类,不用将实例保存到变量中
          new Apple().eat();
  
          UserService userService =  new UserService(){
              @Override
              public void hello(){
              }
          };
      }
  }
  
  class Apple{
      public void eat(){
          System.out.println("1");
      }
  }
  
  interface UserService{
      void hello();
  }