Day18:面向对象编程上篇(面向对象编程本质:以类的方法组织代码,以对象的组织(封装数据))

# 面向对象编程

Java的核心思想就是OOP(面向对象编程)

1.初识面向对象

面向过程&面向对象

属性+方法=类

面向过程思想

​ 步骤清晰简单,第一步做什么,第二步做什么

​ 面对过程适合处理一些较为简单的问题

面向对象思想

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

​ 面向对象适合处理复杂的问题,适合处理需要多人协作的问题!

就像学方法一样,自己写也可也,但是有人写好了我们可以直接拿来调用,这就是面向对象

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

什么是面向对象

面向对象编程(Object-Oriented Programming,OOP)

面向对象编程的本质就是:以类的方法组织代码,以对象的组织(封装)数据

抽象(abstraot):简化的意思,就是把某个东西简化成几个点

三大特性

封装

继承:子类继承父类

多态:因为继承,所以有多态

封装就是第一题,第二题,或者语文卷子,数学卷子

继承就是直角三角形继承自三角形,前者是后者的子类

而继承必然导致多态,有直角三角形,就必然有非直角三角形等等

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

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

2.方法回顾和加深

方法的定义

​ 修饰符

​ 返回值类型

break和return的区别:break:跳出switch结素循环;return 结束循环

​ 方法名:注意规范 见名知意

​ 参数列表:参数类型,参数名…可变长参数

​ 异常抛出:疑问后面讲解

package com.oop;

import java.io.IOException;

//Demo01 类
public class demo01 {

    //main 方法
    public static void main(String[] args) {

    }

    /*
    修饰符 返回值类型 方法名(...参数){
        //方法体
        return 放回值;
    }
     */
    public String sayHello(){
        return "hello world"
    }

    //void是空
    //return结束方法 返回值或空
    public void hello(){
        return;
    }

    //a,b形参
    public int max(int a,int b){
        return a>b ? a : b;//三元运算符
    }

    //数组下标越界:Arrayindexoutofbounds

    //异常抛出的方法才是完整的
    public void readFile(String file) throws IOException{

    }
}

方法的调用:调用

​ 静态方法

public class Student {
//静态方法
public static void say(){
    System.out.println("学生说话");
}
}

静态调用

public class Demo02 {

    public static void main(String[] args) {
        Student.say();//静态方法调用
    }
}
        

​ 非静态方法:避免了外部直接调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yxLQozY3-1645627593021)(D:\Javanotebooks\jietu\92.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9qyS3IoX-1645627593022)(D:\Javanotebooks\jietu\93.png)]

所以:静态方法和非静态方法之间并不能调用

形参和实参

​ 值传递和引用传递

​ this关键字

eg:对象A的名字叫张三,对象B的名字叫李狗蛋。对象的名字属性都有自己独一无二的值

由于static修饰的表示属于类,因此如果想访问类的方法或者变量,则可以直接通过类名.方法名() / 类名.变量 进行访问

所谓动态和静态的方法,对于一个类来说,如果没有被static修饰的成员变量或成员方法,那么每实例一个新的对象(new),这些非static所修饰的类都属于对象

非静态的调用得先new

形参和实参

package com.oop;

public class Demo03 {
    public static void main(String[] args) {
        //实际参数和形式参数类型要相同
        int add = new Demo03().add(1, 5);
        System.out.println(add);
    }

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


}

值传递和引用传递

值传递:复制一份,引用传递:新建快捷方式

package com.oop;

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;
    }

}
package com.oop;

//引用传递:对象,本质还是值传递

//对象,内存

public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);//null

        //非同类非静态用对象调用
        Demo05.change(person);
        System.out.println(person);//子聿
    }

    public static void change(Person person){
        //Person是一个对象:指向的是 Person person = new Person();可以改变属性
        person.name = "子聿";
    }
}

//定义了一个Person类,有一个属性name,并不是内部类
class Person{
    String name;
}

this关键字:代表当前这个类或当前这个对象

类和对象的关系

类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物。

​ 动物、植物、手机、电脑…

​ Person类、Pet类、Car类等、这些都是用来秒速/定义某一类具体的事物应该具备的特点和行为

对象是抽象概念的具体实列

​ 张三就是人的一个具体实列,张三家里的旺财就是狗的一个具体实例

​ 能够体现出特点,展现出功能的是具体的实例,而不是一个抽象的概念

创建和初始化对象

使用new关键字创建对象

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

package com.oop.demo02;

//学生类(一个类只存在属性和方法)
public class Student {
    //属性:字段
    String name;//NULL 默认
    int age;//NULL o

    //方法
    //学生类是学生的属性(姓名) 方法(能干什么)
    //创建的学生对象是一个具体的学生(有头有脸)
    public void study(){
        System.out.println(this.name+"在学习");//学生在学习,但是学生是变化的,所以用this来指代
    }


}

//person-->身高,体重等
//学程序好:对世界进行更好的建模!
//面向对象编程:以类的方式组织代码,以对象的组织封装数据
package com.oop.demo02;

//一个项目应该只存在一个main方法(总测试类)
public class Application {
    public static void main(String[] args) {

        //类:抽象的,实例化
        //类实例化之后会返回一个自己的对象
        //student对象就是一个Student类的具体实例
        Student student = new Student();
        Student xiaoming = new Student();
        Student xh = new Student();


        xiaoming.name ="小明";
        xiaoming.age = 18;

        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);


        xh.name ="小红";
        xh.age = 19;

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

构造器

类中的构造器也称为构造方法,是在进行创建对象的时候必须调用的,并且构造器又以下两个特点:

1.必须和类的名字相同

2.必须没有返回值类型,也不能写void

构造器必须要掌握

1.一旦定义了有参构造,无参就必须显示定义
2.用来初始化值

alt+insert:生成构造器

//一旦定义了有参构造,无参就必须显示定义
package com.oop.demo02;

//java--->class
public class Preson {

    //一个类即使什么都不写,他也会存在一个方法

    String name;
    String age;


    //无参构造器
    //实例化初始值
    //1.使用new关键字,本质是在构造器
    public Preson(){

    }

    //有参构造器
    //1.一旦定义了有参构造,无参就必须显示定义
    //2.用来初始化值
    public Preson(String name){
        //this.name代表的是参数传下来的name ,
        // 而后面的name是有参的name
        this.name = name;
    }
    //alt+insert生成构造器


}
/*
 public static void main(String[] args) {
       //new 实例化了一个对象
        Preson preson = new Preson();
        System.out.println(preson.name);

    }
 */

构造器:
1.和类名相同
2.没有返回值
作用:
new本质调用构造器
初始化对象的值
注意点
1.定义了有参构造之后想使用无参构造,显示的定义一个有参构造

3.对象的创建分析

4.面向对象的三大特征

5.抽象类和接口

6.内部类及OOP实战

lt+insert生成构造器

}
/*
public static void main(String[] args) {
//new 实例化了一个对象
Preson preson = new Preson();
System.out.println(preson.name);

}

*/


**构造器:**
**1.和类名相同**
**2.没有返回值**
**作用:**
**new本质调用构造器**
**初始化对象的值**
**注意点**
**1.定义了有参构造之后想使用无参构造,显示的定义一个有参构造**



上一篇:AngularJs开发——指令与控制器间的通信


下一篇:注解与反射