java方法与面向对象基础

方法

作用

封装一段代码的语法结构，可以被重复调用，以此提高代码的复用性，提高开发效率，让程序逻辑更清晰

定义

方法的完整定义格式

修饰符 返回值类型 方法名(参数列表){
	需要执行的代码
	return 返回值;
}

如果方法没有结果数据需要返回，返回值类型申明为：void

public static int sum(int a, int b){
    int c = a+b;
    return c;
}    ```

方法的注意事项

1. 方法与方法之间是平级关系，不能嵌套定义。
2. 方法的返回值类型为void（无返回值），方法内则不能使用return返回数据，如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。
3. return语句下面，不能编写代码，因为永远执行不到，属于无效的代码。
4. 方法不调用就不执行, 调用时必须严格匹配方法的参数情况。
5. 有返回值的方法调用时可以选择定义变量接收结果，或者直接输出调用，甚至直接调用；无返回值方
6. 法的调用只能直接调用。

值传递

• 你传输实参给方法的形参，传输的不是实参本身，而是实参中存储的数据的值的一个副本。
• 无论是基本数据类型还是引用数据类型的参数，都是满足值传递，基本类型的参数传输的是存储的数据，引用类型的参数传输的是存储的地址值。

方法重载：

同一个类中，方法名称相同，形参列表必须不同，才是方法重载
方法重载的好处：方法名相同标记是同一个功能，但形参列表不同，体现功能的不同
识别方法重载的技巧：
同一个类中，方法名称相同，形参列表必须不同，才是方法重载，其他的都不管，
形参列表不同：形参的个数，类型，顺序不同。不关心形参变量的名称

面向对象编程（oop）

面向对象：把现实世界中的事物全部看成一个一个的对象来解决问题的。（万物皆对象）

类、对象

类：相同事物共同特征的描述
对象：对象是类的具体的实例。
在Java中必须先定义类，才能得到对象。

定义类来创建对象

public class 类名{
	...
}

定义类有一些注意事项

1. 类名首字母建议大写，有意义，满足驼峰，不要用关键字，合法的标志符
2. 一个Java文件中可以定义多个类，但是只能一个类是public修饰的，而且public修饰的类名必须成为Java代码的文件名称，否则报错！

创建对象
类名 对象名 = new 构造器()；
对象的使用
对象名.成员变量
对象名.成员方法

构造器

• 无参数构造器：初始化一个类的对象，里面的数据都是默认值
• 有参数构造器：初始化一个类的对象，并且可以同时为对象赋值。
• 任何类写出来自带一个无参数构造器，写不写都有
• 如果在类中定义了一个有参数构造器，那么无参数构造器就消失了，此时，如果还要使用无参数构造器，就必须自己写一个。

//Car.java
package construct;

public class Car {
    String name;
    double price;

    //无参数构造器
    public Car(){
        System.out.println("无参数构造器被调用了");
    }

    //有参数构造器
    public Car(String n,double p){
        System.out.println("有参数构造器被调用了");
        name = n;
        price = p;
    }
}

-------分---------割--------------线--------------------------

//Test.java
package construct;

public class Test {
    public static void main(String[] args) {
        //调用构造器得到对象
        Car c = new Car();
        System.out.println(c.name);

        //有参数构造器，在构造对象时传入参数
        Car c1 = new Car("奔驰",400000);
        System.out.println(c1.name);
        System.out.println(c1.price);
    }
}

this

this的作用：代表了当前对象的地址，可以访问当前对象的成员变量和成员方法。
this在方法中，谁调用这个方法this就代表谁
this在构造器中，代表构造器正在初始化的那个对象。

//Test.java
package thisDemo;

public class Test {
    public static void main(String[] args) {
        //目标 理解this关键字的作用
        Car c = new Car();
        c.run();

        Car c1 = new Car("宝马",400000);
        System.out.println(c1.name);
        System.out.println(c1.price);
        c1.getName();
    }
}

-----------------------------
//Car.java
package thisDemo;

public class Car {
    String name;
    double price;
    public Car(){
        System.out.println("无参数构造器中的this"+this);				//打印当前对象所在的地址
    }

    public Car(String name,double price){
        this.name =name;
        this.price=price;
    }

    public void run(){
        System.out.println("方法中的this"+this);			//打印当前对象所在的地址
    }

    public void getName(){
        this.name = "奥迪";
        System.out.println(this.name);				//输出奥迪
    }
}

封装

面向对象的三大特征：封装、继承、多态。
封装的基本思想：决定属性和行为归属谁的问题
封装的原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为
private修饰的属性，方法只能在类内部访问

标准JavaBean

作用：创建对象，封装数据的。
定义：就是所谓的实体类（学生类，老师类，汽车类，票类，人类）
标准Bean的书写要求：
成员变量建议private私有化，只能在类内部访问。
提供成套的getter和setter方法暴露取值和赋值
必须提供无参数构造器。

// User.java
package user;

public class User {
    //成员变量私有化
    private String name;
    private double age;
    private char sex;

    //提供无参数构造器，本来就存在不需要再写

    //必须为成员变量设置getter和setter方法
    public String getName() {
        return name;
    }

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

    public double getAge() {
        return age;
    }

    public void setAge(double age) {
        this.age = age;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}
----------------------------
// Test.java
package user;

public class Test {
    public static void main(String[] args) {
        User u = new User();
        u.setName("张三");
        u.setAge(99);
        u.setSex('男');
        System.out.println(u.getName());
        System.out.println(u.getAge());
        System.out.println(u.getSex());
    }
}