面向对象的编程(oop)

初识面向对象

面向对象&面向过程

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

什么是面向对象

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

方法回顾和加深

  • 方法的定义
    • 修饰符
    • 返回类型
    • break 和 return 的区别
    • 方法名
    • 参数列表
    • 异常抛出
  • 方法的调用
    • 静态方法
    • 非静态方法
    • 形参和实参
    • 值传递和引用传递
    • this 关键词

非静态

  1. 值传递

    package com.oop.demo01;
    
    //值传递
    public class Demo04 {
        public static void main(String[] args) {
            int a = 1;
            System.out.println(a); // 1
    
            Demo04.change(a);
    
            System.out.println(a); // 1
        }
    
        //返回值为空
        public static void change(int a){
            a = 10;
        }
    
    }
    
    1. 引用传递
    package com.oop.demo01;
    
    //引用传递:对象,本质还是值传递
    // 对象,内存!
    
    public class Demo05 {
        public static void main(String[] args) {
            Person person = new Person();
            System.out.println(person.name); //null
    
            Demo05.change(person);
            System.out.println(person.name); //中华儿女
    
        }
    
        public static void change(Person person){
            //person 是一个对象:指向的 ---> Preson person = new Person(); 这是一个具体的人,可以改变属性
            person.name = "中华儿女";
        }
    
    
    }
    
    //定义了一个Person类,有一个属性:name
    class Person{
        String name; // null
    }
    

对象的创建分析

类与对象的关系

  • 类是一种抽象的数据类型,它是对某一种食物整体描述/定义,但是并不能代表某一具体事物
    • 动物、植物、水果…
    • Preson类、Pet类、Car类等,这些都是描述/定义某一类具体的事物应该具有的特点和行为
  • 对象是抽象概念的具体实例
    • 张三、旺财等
    • 能够体现出特点,展显出功能的具体的实例,而不是以一个抽象的概念

创建与初始化对象

  • 使用new关键字创建对象
  • 使用new关键字创建的时候,除了分配内存空间外,还会给创建好的对象进行默认初始化,以及对类中构造器的调用
  • 类中构造器也称为构造方法,是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点:
    1. 必须和类的名字相同
    2. 必须没有返回类型,也不能写void
  • 构造器(重点难点)
  1. package com.oop.demo02;
    public static void main(String[] args) {
    
            //类:抽象的,实例化
            //类实例化后悔返回一个自己的对象
            //student 对象就是一个Student类的具体实例!
    
            Student xiaoming = new Student();
    
            xiaoming.name = "小明";
            xiaoming.age = 3;
    
            System.out.println(xiaoming.name);
            System.out.println(xiaoming.age);
            xiaoming.study();
    
        }
    
    //学生类
    public class Student {
    
        //属性:字段
        String name; // null
        int age; //0
    
        //方法
        public void study(){
            System.out.println(this.name + "在学习");
    
        }}
    
    
    
    
  2. package com.oop.demo02;
    public static void main(String[] args) {
    
            //new 实例化一个对象
            Person person = new Person("中华儿女");
    
            System.out.println(person.name);
        }
    
    
    //java --> class
    public class Person {
    
        //一个类即使什么都不写,它也会存在一个方法(存放在class文件中)
        //显示定义构造器
    
        String name;
        int age;       //可以通过快捷键 alt + insert 来生成构造器
    
    
        //实例化初始值
        //1.使用new关键字,本质是在调用构造器
        //2。用来初始化值
    
        public Person(){
    
        }
        //有参构造:一旦定义了有参构造,无参就必须显示定义
        public Person(String name){
            this.name = name;
    
        }
    }
    
    /*
    
    几点说明:
          构造器:
             1.和类名相同
             2.没有返回值
          作用:
             1. new 本质在调用构造方法
             2. 初始化对象的值
          注意点:
             1.定义有参结构之后,如果想使用无参构造,显示的定义一个无参的构造
          快捷键:
            Alt + Insert
    
          this. 的使用
     */
    
  • 内存分配

1
2
3
4

  • 总结

    public class Conclusion {
        /*
              1. 类与对象
                  类是一个模板:抽象  ,对象是一个具体实例
              2. 方法
                  定义,调用
              3. 对应的引用
                  引用类型:  基本类型(8)
                   对象是通过引用来操作的; 栈 ---> 堆
    
              4. 属性:字段Filed 成员变量
                默认初始化:
                     数字: 0  0.0
                     char :  u0000
                     boolean :  false
                     引用 : null
    
                  修饰符  属性类型  属性名  =  属性值!
    
              5.对象的创建和使用
             - 必须使用 new 关键字创建对象,构造器 Person person = new Person();
             - 对象的属性  xiaoming.age
             - 对象的方法  xiaoming.study()
    
              6. 类
                 静态的属性  属性
                 动态的行为  方法
         */
    }
    

面向对象三大特征(重点)

封装

  • 该露的露,该藏的藏
    • 程序设计追求**“高内聚,低耦合”**。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。
  • 封装(数据的隐藏)
    • 通常大的项目结构,应被禁止直接访问一个对象中的数据的实际表示,而是应该通过操作接口来访问,这就是信息隐藏
  • 属性私有,get/set
/*
总结:
     1.提高程序的安全性,保护数据
     2.隐藏代码的实现细节
     3.统一接口
     4.系统的可维护性增加了
*/
import com.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("中华儿女");

        System.out.println(s1.getName());

        s1.setAge(99);
        System.out.println(s1.getAge());

    }


}
//类   private: 私有
class Student {

    //属性私有
    private String name; //名字
    private int age; //年龄
    private char sex; //性别


    //提供一些可以操作这个属性的方法
    // 提供一些 public 的 get 、set 的方法

    //get 获得这些数据
    public String getName() {
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }


//可以通过快捷键 Alt + Insert
    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {   //可以加一些条件
        if(age>120 || age<0){ //不合法情况
            this.age = 3;
        }else {
            this.age = age;
        }

    }
}

继承

  • 继承的本质是对某一批类的抽象,从而让实现对现实世界更好的建模
  • extands的意思是“扩展”。子类是父类的扩展。
  • JAVA中,类只有单继承,没有多继承
    • 继承是类和类之间的一种关系。除此之外,关系还有依赖、组合、聚合等
    • 继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用的关键字 extends来表示
    • 子类和父类之间,从意义上将应该是具有“is a”的关系
  • object 类(在Java中,所有的类,都是默认直接或者间接继承Object(相当于祖父类))

object

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

super
super

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

重写,子类的方法和父类必须要一致,方法体不同!

为什么要重写呢?
     1.父类的功能,子类不一定需要,或者不一定满足
     Alt + Insert : override
*/

override

多态

  • 动态编译: 类型:可扩展性
  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
  • 一个对象的实际类型是确定的,但可以指向对象的引用类型有很多
  • 多态存在的条件
    • 有继承关系
    • 子类重写父类的方法
    • 父类引用指向子类对象
  • 注意 : 多态是指方法的多态,属性没有多态性
/*
多态的注意事项:
1.多态是方法的多态,属性没有多态
2.父类和子类,有联系   若出现类型转换异常! ClassCastException!
3.存在条件: 继承关系,方法需要重写,父类引用指向子类对象! Father f1 = new Son();

以下不需要重写:(没有重写就没有多态)
      1. static 方法,属于类,不属于实例
      2. final 常量
      3. private方法
      
1.父类引用指向子类对象
2.把子类转化为父类,向上转型
3.把父类转化为子类,向下转型,强制转换
4.方便方法调用,减少重复代码!
*/
  • instanceof (类型转换) 引用类型,判断一个对象是什么类型~
public class Application {

    public static void main(String[] args) {

        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();

        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); //编译器报错
        //System.out.println(student instanceof String);  //编译器报错

多态

Static 关键字

  • 静态可以调用静态,静态不能调用非静态,非静态可以调用静态‘
  • 加了static 就从属于这个类,其他人用不了,如要调用 new 一个对象
package com.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(Student.score); //报错
        System.out.println(s1.age);
        System.out.println(s1.score);
        
        run(); //报错
        s1.run();
        new Student().run();
        Student.go();
        go();
    }
}

public class Person {

    //2.赋初值
    {
        System.out.println("匿名代码块");
    }

    //1.:只执行一次~
    static {
        System.out.println("静态代码块");
    }

    //3
    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("=================");
        Person person2 = new Person();
    }
}
/* 
输出结果:
静态代码块
匿名代码块
构造方法
=================
匿名代码块
构造方法
*/

抽象类和接口

抽象类

  • **abstract ** 修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类
  • 抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类
  • 抽象类,不能使用new关键字来创建对象,它是用来让子类继承的
  • 抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的
  • 子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类
/*
1. 不能 new 这个抽象类,只能靠子类来实现它;约束!
2. 抽象类可以写出普通的方法
3. 抽象方法必须在抽象类中
存在的有意义在于:抽象出来~ 提高开发效率
*/

abstract

接口

  • 普通类:只能具体来实现
  • 抽象类:具体实现和规范(抽象方法)都有!
  • 接口:只有规范!自己无法写方法~专业的约束!约束和实现分离:面向接口
  • 接口就是规范,定义的是一组规则,实现了现实世界中“如果你是···则必须能···”的思想
  • 接口的本质是契约,就像是人间的法律,制定好后就必须好好遵守
  • OO的精髓,是对对象的抽象,最能体现这一点就是接口。
  • 声明类的关键字是 class ,声明接口的关键字是 interface
/*
作用:
    1.约束
    2.定义一些方法,让不同的人实现~
    3. public abstract
    4. public static final
    5. 接口不能被实例化~,接口中没有构造方法~
    6. implements可以实现多个接口 
    7. 必须要重写接口中的方法
    
*/

接口

Java学习

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值