面对对象编程思想

面向对象思想就是将生活客观存在的事物，通过代码的形式将其描述出来。当我们再看到这些对象的时候，就联想到他应该具有什么样的功能

比如：

洗衣机可以洗衣服，甩干，烘干

学生可以吃饭，睡觉，学习

核心

1.类

可以描述生活中所有的事物

**   类的组成**

              属性：指事物的特征。例如：狗事物（品种、价格、年龄等）

              行为（方法）：指事物能执行的操作，例如：狗事物（吃东西、睡觉、看家）

在代码中，属性是通过成员变量体现的。行为是通过成员方法来体现的。

2.对象

概念：

     就是真实世界中的实体，现实世界中每个实体都是一个对象，是一种具体都概念

特点：

对象具有属性和行为。

对象具有变化的状态。

对象具有唯一性。

对象都是某个类别的实例。

一切皆为对象，真实世界中的所有事物都可以视为对象。

类和对象的关系

• 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
• 对象：是能够看得到摸的着的真实存在的实体
• 简单理解：类是对事物的一种描述，对象则为具体存在的事物

成员方法的定义与调用

定义格式

//普通
public void 方法名() {  
    // 方法体
}

//带参数
public void 方法名 ( 数据类型 变量名) {
     // 方法体
}

//带返回值
public 数据类型 方法名() {
    // 方法体
    return 返回值;
}

//及带参数又带返回值
public 数据类型 方法名 (数据类型 变量名1，数据类型 变量名2...) {
    //方法体
    return 返回值;//将方法的运行结果返回给调用者
}

//方法的通用格式（掌握）
public static 返回值类型 方法名(参数) {
   方法体; 
   return 数据 ;
}

/*
格式详解：
    public static 	修饰符，目前先记住这个格式
    返回值类型	方法操作完毕之后返回的数据的数据类型,如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
    方法名		调用方法时候使用的标识
    参数		由数据类型和变量名组成，多个参数之间用逗号隔开
    方法体		完成功能的代码块
    return		如果方法操作完毕，有数据返回，用于把数据返回给调用者

定义方法时，要做到两个明确
    明确返回值类型：
        主要是明确方法操作完毕之后是否有数据返回。
        如果没有，写void。
        如果有，写对应的数据类型。
    明确参数：
        主要是明确参数的类型和数量
        调用方法时的注意：
        void类型的方法，直接调用即可
        非void类型的方法，推荐用变量接收调用
* */

注：

1.可以带多个参数用逗号隔开

2.返回值类型可以为：

a;基本类型

b.数组

c.字符串

d.自定义的类

调用方法

对象名.方法名();

public class Student {
    //属性
    String name;
    int age;

    //行为 --- 学习
    public void study(){
        System.out.println(name + "学生学习Java");
    }

    //行为 --- 吃饭
    public void eat(){
        System.out.println(name + "学生吃饭");
    }

    //行为 --- 睡觉
    public void sleep(){
        System.out.println(name + "学生睡觉");
    }

}

public class Lianxi {
    /*
        成员方法的调用格式:
            对象名.方法名();
     */
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "张三";
        stu.age = 23;
        System.out.println(stu.name + "今年：" + stu.age + "岁");

        stu.sleep();
        stu.eat();
        stu.study();
    }
}

对象名.方法名(参数);

参数有形参和实参：

形参：全称形式参数，是指在定义方法时，所声明的参数

实参：全称实际参数，调用方法时，所传入的参数

例：

public class Phone {
    String brand;
    int price;

    //定义带有参数的方法
    public void call(String name){//String name就是形参
        System.out.println("给" + name + "打电话");
    }

    //定义没有参数的方法
    public void sendMessage(){
        System.out.println("群发短信");
    }
}


public class Lianxi {
    public static void main(String[] args) {
        Phone p = new Phone();
        //有参数的方法调用格式: 对象名.方法名(参数);
        p.call("张三");  //张三就是实参
        p.call("李四");  //李四也是实参
        
        //没有参数的方法调用格式： 对象名.方法名();
        p.sendMessage();
    }
}

注意事项：

方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错

方法定义时，多个参数之间使用逗号分隔

方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

数据类型 变量名 = 对象名.方法名(参数...);//相当于就是拿一个变量接收一下方法的运行结果。

public class Phone {
    String brand;
    int price;

    //有参有返回值的方法
    public int add(int a, int b){
       int c = a + b;
       return c;
    }
}

public class TestPhone {
    public static void main(String[] args) {
        Phone p = new Phone();
        //调用有参有返回值的方法。
        //必须拿一个变量接收一下方法的运行结果。
        int result = p.add(10,20);

        System.out.println(result);
    }
}

方法的作用和注意事项

作用

提高代码的复用性

提高代码的可阅读性

 注意事项

方法必须先创建才可以使用，该过程称为方法定义

方法不调用就不执行

方法与方法之间是平级关系，不能嵌套定义

方法的定义顺序和执行顺序无关

方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写如果要编写return，后面不能跟具体的数据。

return语句下面，不能编写代码，因为永远执行不到，属于无效的代码 

this关键字

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）。
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

注：在这个重名问题中就引出了一个就近原则

在方法中调用变量，谁离调用者越近，那么方法中就会调用谁。

this关键字就是解决这个问题的

例：

public class Student {
    String name;
    int age;

    public void hello(String name){
        // 就近原则 --- 访问局部变量
        System.out.println("局部变量" + name);
        // 利用this --- 访问成员变量
        System.out.println("成员变量" + this.name);
    }
    
    public void unm(){
        System.out.println("unm方法中的this" + this);
    }
}

public class Lianxi {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "张三";
        stu.age = 12;
        stu.hello("李四");
    }
}

this内存图

this代表当前类的对象引用（地址值）

哪个对象调用this所在的方法，this就代表哪一个对象。

作用：用于区分局部变量和成员变量重名的问题。

方法的相互调用

this 可以用于调用本类的成员变量和成员方法。

调用成员变量：

如果跟局部变量没有重名，this可以省略。

调用成员方法：

this 可以直接省略。

例：

public class Student {
    String name;
    int age;

    public void study() {
        System.out.println("学习");
    }

    public void sleep() {
        System.out.println("睡觉");
    }

    public void eat() {
        System.out.println("吃饭");
    }

    public void show(){
        //如果不存在重名，这里的this可以省略
        System.out.println(this.name);
        System.out.println(this.age);
        //调用其他成员方法，this可以省略。
        this.study();
        this.sleep();
        this.eat();
    }
}

public class Lianxi {
    public static void main(String[] args) {
        Student s = new Student();
        s.show();
    }
}

权限修饰符

可以修饰类、类成员（包括成员变量和成员方法）

 分类：

private ：只能在本类当中进行访问。使用对象：变量、方法。

（default）默认： 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

protected： 对同一包内的类和所有子类可见。使用对象：变量、方法。 

public ：权限最大，可在任意位置进行访问。使用对象：类、接口、变量、方法

方法重载

方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载。

多个方法在同一个类中。

多个方法具有相同的方法名。

多个方法参数的数量不同、类型不同或者数据类型的顺序不相同。

好处：
在编写代码时，不需要起那么多方法名了，相同功能的方法，名字可以一样。

在调用方法时，不用记忆过多繁琐的方法名字。

注意事项：

重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式

重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

例：

public class Lianxi {
    public int unm(int a, int b) {
        return a + b;
    }

    public double unm(double a, double b) {
        return a + b;
    }

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

    public double unm(double a, double b, double c) {
        return a + b + c;
    }
}

注：数据类型的顺序不同可以构成重载，但是不建议

构造方法

格式：

方法名与类名相同，大小写也要一致

没有返回值类型，连void都没有

没有具体的返回值（不能由retrun带回结果数据）

作用：

用的于给对象的数据（属性）进行初始化

什么时候执行：

创建对象的时候调用，每创建一次对象，就会执行一次构造方法

不能手动调用构造方法

例：

注：当没有写构造函数的时候有默认空参构造函数

构造方法的注意事项：

构造方法的创建 :

​    如果没有定义构造方法，系统将给出一个默认的无参数构造方法。

​    如果定义了构造方法，系统将不再提供默认的构造方法。

构造方法的重载：

​    如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法。

建议 :

​    无论是否使用，都手动书写无参数构造方法，和带参数构造方法。

封装

隐藏实现细节，仅对外暴露公共的访问方式

常见的体现：
将代码抽取到方法中，这是对代码的一种封装

将属性抽取到类当中，这是对数据的一种封装

例：

/*不封装数据，那么3个学生信息需要操作6个数据。
把姓名和年龄封装成一个Student对象再进行操作。这样我们只要操作3个数据即可。
那如果1个学生对象有10个属性呢？
如果不封装，3个学生对象要操作30个数据。
如果封装，3个学生对象依旧只要操作3个数据即可。*/

//把属性抽取到类当中，这是对数据的一种封装
public class Student {
    String name;
    int age;
}

public class Lianxi{
    public static void main(String[] args){
        //情况一：不封装数据
        //第一组学生信息
        String name1 = "张三";
        int age1 = 23;
        //第二组学生信息
        String name2 = "李四";
        int age2 = 24;
        //第三组学生信息
        String name3 = "王五";
        int age3 = 25;

        //情况二：把姓名和年龄封装成一个Student对象再进行操作
        Student stu1 = new Student();
        stu1.setName("张三");
        stu1.setAge(23);

        Student stu2 = new Student();
        stu2.setName("李四");
        stu2.setAge(24);

        Student stu3 = new Student();
        stu3.setName("王五");
        stu3.setAge(25);
    }
}

这样提高了代码的复用性

标准JavaBean类

一个标准的JavaBean类包含以下几个部分：

成员变量：使用 private 修饰

构造方法：

​    提供一个无参构造方法

​    提供一个带多个参数的构造方法

成员方法 ：

​    提供每一个成员变量对应的 setXxx() / getXxx()

使用JavaBean类：

利用无参构造创建对象，使用 setXxx() 赋值
利用带参构造方法直接创建带有属性值的对象

例：

class Dog{
    private String name;
    private long phone;
    private char sex;

    public Dog(String name, long phone, char sex) {
        this.name = name;
        this.phone = phone;
        this.sex = sex;
    }

    public Dog(){}

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public long getPhone() {
        return phone;
    }

    public void setPhone(long phone) {
        this.phone = phone;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

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

    }
}