面向对象编程

时间：2020-04-04 23:44:26 收藏：0 阅读：76

面向对象编程

面向对象

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后才对某个分类的细节进行面向过程的思索
面向对象适合处理复杂的问题，适合需要多人协助的问题
面向对象的本质：以类的方式组织代码，以对象的组织（封装）数据
面向对象的三大特性：
- 封装
- 继承
- 多台

构造器

语法：

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来进行修饰
  - 注意点：
  - 自己整理的笔记，有用的话可以看看

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