面向1-类和对象-方法、new的定义和使用

面向对象编程OOP

面向

面向对象和面向过程

面向对象oop-分类的思维方式-本质——以类的方式组织代码，以对象的组织（封装）数据

抽像+封装+继承+多态

认识上-先有对象（具体的事物）再有类（对对象的抽象） 代码上-先有类再有对象（类是对象的模板）

面向过程-线性步骤分析方式

类（属性＋方法构成）-描绘一系列事物的共同特征并将它抽象出来-比如哺乳动物

对象-具体的示例-比如人

使用new关键字创建对象-分配内存空间

​ 默认初始化

​ 对类中的构造器（必须掌握）进行调用

构造器-构造器又叫构造方法，在进行创建对象时必须要调用的

1. 必须和类的名字相同

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

总结

1、类与对象

类是一个 抽象的 模板，对象是一个 具体的 实例

2、方法

定义、调用

3、对应的引用

引用类型：基本类型（8）以外

对象是通过 引用 来操作的：引用在栈中，而真实属性是在堆中

4、属性：字段field 成员变量

默认初始化：数字-0、0.0，char-u000，boolean-false，引用-null

赋值 修饰符 属性类型 属性名 = 属性值；

5、对象的创建和使用

1. 必须使用new关键字创造对象，且必须有构造器 ；Person moulixu = new Person()
2. 调用对象的属性 mouixu.name
3. 调用对象的方法 moulixu.sleep()

6、类

静态的属性 属性

动态的行为 方法

7、this、类、.具体参数指向

this指代当前这个类

this. 或 类名. 点后面跟参数（8大类型 或 引用类型）

方法

1、回顾方法定义

//回顾方法定义
package oop;

public class a1 {
    // main方法-用来执行，一个项目应该只有一个main方法
    public static void main(String[] args) {

    }
    /* 方法定义
    修饰符 返回值类型 方法名（参数类型和参数名）{
           方法体；
           return 返回值；
     }
     注：1、方法名-驼峰原则和见名知意
        2、返回数值应该和定义类型相同
        3、参数可定义多个
        4、return和break
    return代表运算结束返回结果，不再执行下一行代码；返回数值应该和定义类型相同
    break跳出switch,结束循环
     */
    public String sayHello(){
        return "Hello,World";
    }
    //空方法
    public void hello(){
        return;
    }
    //比大小
    public int max(int a,int b){
        return a>b?a:b;//三元运算符，是就a,不是就b
    }

}

2、回顾方法的调用-递归

/* 回顾方法的调用-递归

 */
package oop;

public class a2 {
    public static void main(String[] args) {
        //同态可以调用，不同态不可以-需要将非静态实列化
        //静态方法+static
        a3.say();
        //非静态方法
        //实列化这个类new; 对象类型 对象名 = 对象值；
        a3 a3 = new a3();
        a3.print();

        //实际参数和形式参数的类型要一一对应！
        int add = a2.add(3,5);
        System.out.println(add);

        //值传递
        int a=1;
        System.out.println(a);//输出值唯1
        a2.change(a);
        System.out.println(a);//输出值也为1

        //引用传递：传递一个对象，本质还是值传递
        Person person = new Person();
        System.out.println(person.name);//null
        a2.cite(person);
        System.out.println(person.name);//牟李旭
    }
    public static int add(int a,int b){
        return a+b;
    }
    //返回值为空
    public static void change(int a){
        a=10;
    }
    public static void cite(Person person){
        //person是一个对象，指向的Person person = new Person();这是一个具体的人，可以改变属性
        person.name="牟李旭";
    }

}
//一个类里面可以有多个class 但只能有一个public
//定义了一个Person类，有一个属性name
class Person{
    String name; //默认值为null
}

/*
//辅助学习方法的调用
package oop;

import java.sql.SQLOutput;

public class a3 {
    //静态方法
    public static void say(){
        System.out.println("静态方法");
    }
    public void print(){
        System.out.println("非静态方法");
    }
}
*/

3、类和new的使用

//类是一个模板，通过new关键字来创建具体的实例
package oop;
//学生类-类是一个抽象的模板，通过new关键字创造具体的实例
//以类的方法组织代码，以对象的方式封装程序
public class a4 {
    //类里面只有属性和方法
    // 属性 字段
    String name;//默认null
    int age;//默认零
    //方法
    public void study(){
        System.out.println(this.name+"学生在学习");//this.就表示当前这个类

    }
}




/* new的使用
package oop;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类是抽象的，通过new需要实例化
        //类实例化后会返回一个自己的对象！
        //a4对象就是一个a4类的具体实例!-记住以后类的首字母大写
        a4 xiaoming = new a4();
        a4 wangyi = new a4();
        //a4中的是模板为空的，需要定义才能使用
        System.out.println(xiaoming.name);//输出为null
        System.out.println(xiaoming.age);//输出为0
        xiaoming.name ="小明";
        xiaoming.age =18;
        System.out.println(xiaoming.name);//输出为null
        System.out.println(xiaoming.age);//输出为0


    }
}

 */

4、构造器的使用

/* 构造器的使用public+类名;构造器不使用的话，其实系统也会有一个默认的构造器class文件中
alt+insert会生成构造器(condtructor)，根据选择形成 select null生成无参
1、使用new关键字，本质是在调用构造器
2、用来初始化值
 */
package oop;

public class Application {
    public static void main(String[] args) {
        //使用new实例化了一个对象，即使原函数中什么都没有
        People people1 = new People();//一旦定义了有参定义，无参就必须显示定义,否则使用不了
        People people2 = new People("xiaohei");//就会默认走有参构造器
        System.out.println(people1.name);
        System.out.println(people2.name);
    }
}



/*
//辅助理解构造器使用的理解
package oop;
/*
java自动生成的class文件
用idea打开class文件， 项目结构-Moduls-增加目录-加入out-点击ok和applay-out中生成class文件有构造器
结论1、一个类即使什么也不写，也会存在一个方法打开clss可以看到
   2、也可以自己定义构造器
   都必须遵守两条规则
         （1）. 必须和类的名字相同
         （2）. 必须没有返回类型，也不能写void
         （3）.new本质在调用构造方法
    3、this.表示当前这个类，后面跟参数
注意点：定义有参构造以后，如果想使用一个无参构造，必须加一个无参构造
 */

public class People {
    String name;
    //实例化初始值
    //显示的定义构造器
    //无参构造器
    public People(){
        this.name = "xiaobai";
    }

    //有参构造器：一旦定义了有参定义，无参就必须显示定义；方法根据参数去选择
    public People(String name){
        this.name =name;//this.name表示的是类参，而后面的name表示的是参数
    }
}
*/