面向对象编程

面向对象

• 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后才对某个分类的细节进行面向过程的思索

• 面向对象适合处理复杂的问题，适合需要多人协助的问题

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

• 面向对象的三大特性：

  • 封装

  • 继承

  • 多台

构造器

• 语法：

  package com.chen.oop;
  ?
  import javax.naming.Name;
  ?
  public class Demo01 {
      String name;
      
      public Demo01(){
          this.name= Name;
      }
  }

• 构造器的名字必须和类名相同

• 构造器没有返回值

• 作用：

  • 我们new一个对象时，其实就是在调用构造器

  • 初始化对象的值

• 注意点：当我们构建了新的有参构造器时，我们的默认构造器就会被覆盖掉，所以我们在构建有参构造器是，我们会构造一个默认的空参构造器

• 类里面包含：

  • 静态属性

  • 动态方法

• 创建对象用Person person= new Person()来创建一个Person对象

• 用对象调用其属性：person.name访问属性name

• 用对象调用方法：person.sleep()方法

封装

封装的步骤

• 私有属性

• 空参构造和有参构造

• 共有的get和set方法

• 封装作用：

  • 提高代码安全性

  • 隐藏了代码实现细节，这样就提高了代码的安全性

  • 统一的get和set方法

继承

Java中类只允许单继承，没有多继承，一个儿子只能有一个爸爸，一个爸爸可以有多个儿子

super注意点：

• super调用父类的构造方法，必须在构造方法的第一个

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

• super和this不能同时调用构造方法

this：

• 代表对象不同：

  • this： 本身调用者这个对象

  • super：代表父类对象的应用

• 前提：

  • this：没有继承关系也可以使用

  • super：只能继承条件才可以使用

• 构造方法：

  • this（）；本类的构造

  • super（）；父类的构造

• 重写:需要有继承关系。子类重写父类的方法!

  1. 方法名必须相同 2.多数列表列表必须相同

  2. 修饰符:范围可以扩大但不能缩小: public>Protected>Default>private 4.抛出的异常:范围，可以被缩小。但不能扩大: ClassNotFoundException =-> Exception( 大) 重写。子类的方法和父类必要一一致: 方法体不同! 为什么需婴重写: 1.父类的功能，子类不一 一定需要。或者不一-定满足! Alt + Insert ; override;

多态

• 多态存在的条件：

  1. 必须要有继承关系

  2. 必须要有子类从写父类的方法

  3. 必须要有父类引用指向子类对象 Father father= new Son（）； 父类不能调用子类的方法，

• 多态中指的是方法是多态，而属性不能多态

• 继承中哪些方法不能被重写：

  1. static方法 ，它是属于类，因为static方法加载时候是和类一块加载的

  2. final常量，因为他定义在常量身上，不能被重写

  3. private方法不能被重写，它是私有的

• 继承中哪些属性不能被子类继承：

  1. 父类中的private属性和方法不能被子类继承，是父类独有的属性和方法

  2. static方法能被子类继承，static属性能被继承

  3. final方法能被继承，final属性能被继承

Instanceof

• instanceof是用于强制转换（引用数据类型）

• 强制转化

  • 父-->子 需要强制转换

  • public static void main(String[] args) {
        Student student = new Student();
        //父类强转为子类
        Student person1 = (Student) person;
          person1.eat();
        //直接在调用子类方法时候强转
        ((Student) person).eat();
    ?
    }

• 自动转换

  • 子-->父 自动转换，但是可能会丢失子类中的一些方法

  • public static void main(String[] args) {
        Student student = new Student();
        Person  person = student;
        
    }

package com.chen.demo01;
?
import com.chen.demo02.Person;
import com.chen.demo02.Student;
import com.chen.demo02.Teacher;
public class Application {
    public static void main(String[] args) {
        //关系object>string
        //关系Object>person>student
        //关系object>person>teacher
        Object object = new Student();
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Teacher);//flase
        System.out.println(object instanceof String);//flase
        System.out.println("============================");
        Person person = new Student();
        System.out.println(person instanceof Object); //true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Teacher);//flase
        //System.out.println(person instanceof String);
        System.out.println("============================");
        Student student = new Student();
        System.out.println(student instanceof Object);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Student);//true
        //System.out.println(student instanceof Teacher);
        //System.out.println(student instanceof String);
    }
}

Static

package com.chen.demo03;
?
public class Person {
    {
        //匿名代码块
        System.out.println("匿名代码块");
    }
    static {
        //静态代码块
        System.out.println("static");
    }
    //运行顺序为static>匿名代码块>构造方法
    public void run(){
        System.out.println("构造方法");
    }
}

• 访问静态属性：

  • 类名.静态属性

• 访问静态方法：

  • 类名.静态方法

• static方法的初始化时间在加载类时候一块加载，普通方法在我们调用方法的时候才进行初始化

• static代码块只加载一遍，第二遍加载不会再运行静态代码块

• 非静态方法可以调用静态方法，但是静态方法不能调用普通方法，因为static初始化的早

  package com.chen.demo03;
  ?
  public class Person {
      public static void run(){
          //mothod();   不能调用
          System.out.println("1");
      }  
      public void mothed(){
           run();
          System.out.println("2");
      }
  }

• 如果父类为final类，子类就不能进行继承父类

抽象类

• 抽象类用abstract来进行修饰

• 注意点：

  • 类中有抽象方法的话这个类一定是抽象类，普通类不能创建抽象方法

  • 有抽象方法的类里面的方法不一定是抽象方法，也可以是普通方法

    package com.chen.demo03;
    ?
    public abstract class Person {
    ?
    public abstract void eat();
    public void sleep(){
        
    }
    }

  • 一个普通类继承一个抽象类的话，必须得实现该抽象类的所有抽象方法，该抽象类中的普通方法不需要实现，实现抽象类中的抽象方法是，其实就是在重写该抽象类中的抽象方法体

    ?
    //01
    package com.chen.demo03;
    ?
    public abstract class Person {
    ?
    public abstract void eat();
    public abstract void mouth();
    public void sleep(){
    ?
    }
    }
    //02
    package com.chen.demo03;
    //普通类继承抽象类
    public class Student extends Person {
    ?
        @Override
        public void eat() {
    ?
        }
    ?
        @Override
        public void mouth() {
    ?
        }
    }

  • 抽象类不能被实例化，就是不能被创建为对象（new）

  • 如果一个抽象类继承该抽象类，就不需要实现该抽象类中的抽象方法

    //01
    package com.chen.demo03;
    ?
    public abstract class Person {
    ?
    public abstract void eat();
    public abstract void mouth();
    public void sleep(){
    ?
    }
    }
    //02
    package com.chen.demo03;
    ?
    public abstract class Student extends Person {
    ?
    }

  • 抽象类中不能定义属性，一般可以定义常量,即使定义属性也会被视为常量

    面向对象编程

    面向对象

    • 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后才对某个分类的细节进行面向过程的思索

    • 面向对象适合处理复杂的问题，适合需要多人协助的问题

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

    • 面向对象的三大特性：

      • 封装

      • 继承

      • 多台

    构造器

    • 语法：

      package com.chen.oop;
      ?
      import javax.naming.Name;
      ?
      public class Demo01 {
          String name;
          
          public Demo01(){
              this.name= Name;
          }
      }

    • 构造器的名字必须和类名相同

    • 构造器没有返回值

    • 作用：

      • 我们new一个对象时，其实就是在调用构造器

      • 初始化对象的值

    • 注意点：当我们构建了新的有参构造器时，我们的默认构造器就会被覆盖掉，所以我们在构建有参构造器是，我们会构造一个默认的空参构造器

    • 类里面包含：

      • 静态属性

      • 动态方法

    • 创建对象用Person person= new Person()来创建一个Person对象

    • 用对象调用其属性：person.name访问属性name

    • 用对象调用方法：person.sleep()方法

    封装

    封装的步骤

    • 私有属性

    • 空参构造和有参构造

    • 共有的get和set方法

    • 封装作用：

      • 提高代码安全性

      • 隐藏了代码实现细节，这样就提高了代码的安全性

      • 统一的get和set方法

    继承

    Java中类只允许单继承，没有多继承，一个儿子只能有一个爸爸，一个爸爸可以有多个儿子

    super注意点：

    • super调用父类的构造方法，必须在构造方法的第一个

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

    • super和this不能同时调用构造方法

    this：

    • 代表对象不同：

      • this： 本身调用者这个对象

      • super：代表父类对象的应用

    • 前提：

      • this：没有继承关系也可以使用

      • super：只能继承条件才可以使用

    • 构造方法：

      • this（）；本类的构造

      • super（）；父类的构造

    • 重写:需要有继承关系。子类重写父类的方法!

      1. 方法名必须相同 2.多数列表列表必须相同

      2. 修饰符:范围可以扩大但不能缩小: public>Protected>Default>private 4.抛出的异常:范围，可以被缩小。但不能扩大: ClassNotFoundException =-> Exception( 大) 重写。子类的方法和父类必要一一致: 方法体不同! 为什么需婴重写: 1.父类的功能，子类不一 一定需要。或者不一-定满足! Alt + Insert ; override;

    多态

    • 多态存在的条件：

      1. 必须要有继承关系

      2. 必须要有子类从写父类的方法

      3. 必须要有父类引用指向子类对象 Father father= new Son（）； 父类不能调用子类的方法，

    • 多态中指的是方法是多态，而属性不能多态

    • 继承中哪些方法不能被重写：

      1. static方法 ，它是属于类，因为static方法加载时候是和类一块加载的

      2. final常量，因为他定义在常量身上，不能被重写

      3. private方法不能被重写，它是私有的

    • 继承中哪些属性不能被子类继承：

      1. 父类中的private属性和方法不能被子类继承，是父类独有的属性和方法

      2. static方法能被子类继承，static属性能被继承

      3. final方法能被继承，final属性能被继承

    Instanceof

    • instanceof是用于强制转换（引用数据类型）

    • 强制转化

      • 父-->子 需要强制转换

      • public static void main(String[] args) {
            Student student = new Student();
            //父类强转为子类
            Student person1 = (Student) person;
              person1.eat();
            //直接在调用子类方法时候强转
            ((Student) person).eat();
        ?
        }

    • 自动转换

      • 子-->父 自动转换，但是可能会丢失子类中的一些方法

      • public static void main(String[] args) {
            Student student = new Student();
            Person  person = student;
            
        }

    package com.chen.demo01;
    ?
    import com.chen.demo02.Person;
    import com.chen.demo02.Student;
    import com.chen.demo02.Teacher;
    public class Application {
        public static void main(String[] args) {
            //关系object>string
            //关系Object>person>student
            //关系object>person>teacher
            Object object = new Student();
            System.out.println(object instanceof Object);//true
            System.out.println(object instanceof Person);//true
            System.out.println(object instanceof Student);//true
            System.out.println(object instanceof Teacher);//flase
            System.out.println(object instanceof String);//flase
            System.out.println("============================");
            Person person = new Student();
            System.out.println(person instanceof Object); //true
            System.out.println(person instanceof Person);//true
            System.out.println(person instanceof Student);//true
            System.out.println(person instanceof Teacher);//flase
            //System.out.println(person instanceof String);
            System.out.println("============================");
            Student student = new Student();
            System.out.println(student instanceof Object);//true
            System.out.println(student instanceof Person);//true
            System.out.println(student instanceof Student);//true
            //System.out.println(student instanceof Teacher);
            //System.out.println(student instanceof String);
        }
    }

    Static

    package com.chen.demo03;
    ?
    public class Person {
        {
            //匿名代码块
            System.out.println("匿名代码块");
        }
        static {
            //静态代码块
            System.out.println("static");
        }
        //运行顺序为static>匿名代码块>构造方法
        public void run(){
            System.out.println("构造方法");
        }
    }

    • 访问静态属性：

      • 类名.静态属性

    • 访问静态方法：

      • 类名.静态方法

    • static方法的初始化时间在加载类时候一块加载，普通方法在我们调用方法的时候才进行初始化

    • static代码块只加载一遍，第二遍加载不会再运行静态代码块

    • 非静态方法可以调用静态方法，但是静态方法不能调用普通方法，因为static初始化的早

      package com.chen.demo03;
      ?
      public class Person {
          public static void run(){
              //mothod();   不能调用
              System.out.println("1");
          }  
          public void mothed(){
               run();
              System.out.println("2");
          }
      }

    • 如果父类为final类，子类就不能进行继承父类

    抽象类

    • 抽象类用abstract来进行修饰

    • 注意点：

    • 类中有抽象方法的话这个类一定是抽象类，普通类不能创建抽象方法

    • 有抽象方法的类里面的方法不一定是抽象方法，也可以是普通方法

      package com.chen.demo03;
      ?
      public abstract class Person {
      ?
      public abstract void eat();
      public void sleep(){
          
      }
      }

    • 一个普通类继承一个抽象类的话，必须得实现该抽象类的所有抽象方法，该抽象类中的普通方法不需要实现，实现抽象类中的抽象方法是，其实就是在重写该抽象类中的抽象方法体

      ?
      //01
      package com.chen.demo03;
      ?
      public abstract class Person {
      ?
      public abstract void eat();
      public abstract void mouth();
      public void sleep(){
      ?
      }
      }
      //02
      package com.chen.demo03;
      //普通类继承抽象类
      public class Student extends Person {
      ?
          @Override
          public void eat() {
      ?
          }
      ?
          @Override
          public void mouth() {
      ?
          }
      }

    • 抽象类不能被实例化，就是不能被创建为对象（new）

    • 如果一个抽象类继承该抽象类，就不需要实现该抽象类中的抽象方法

      //01
      package com.chen.demo03;
      ?
      public abstract class Person {
      ?
      public abstract void eat();
      public abstract void mouth();
      public void sleep(){
      ?
      }
      }
      //02
      package com.chen.demo03;
      ?
      public abstract class Student extends Person {
      ?
      }

    • 抽象类中不能定义属性，一般可以定义常量,即使定义属性也会被视为常量

    • 自己整理的笔记，有用的话可以看看

面向对象编程

原文：https://www.cnblogs.com/Kentstudy/p/12634267.html