Day14-01 P60面向对象01：什么是面向对象 P61对象02：回顾方法的定义 P62 对象03：回顾方法的调用 P63对象04：类与对象的创建 P64 面向对象05：构造器详解

Day14–01

P60 面向对象01：什么是面向对象

---

---

P61 面向对象02：回顾方法的定义

1、break：跳出switch，或者用于结束循环

​ return：表示方法运行到此就结束了

2、方法名字：见名知意+首字母小写驼峰原则

3、参数列表：（参数类型，参数名，…，…)

package com.oop.demo01;

//这里的Demo01就是一个类，因为前边有class
public class Demo01 {

    //main方法 这里用于启动这个程序
    public static void main(String[] args) {

    }

    /*
    修饰符  返回值类型  方法名（。。。）{
        //方法体
        return 返回值
     }
     */
    public String sayHello(){

        return "hello,world";//返回一个String类型的字符串
    }

    public void hello(){

        return; //表示什么也不返回，也可以不写return，因为返回值类型为void
    }

    public int max(int a,int b){

        return a>b ? a : b;//三元运算符，如果a>b,则输出a,否则输出b
    }
}

---

---

P62 面向对象03：回顾方法的调用

//静态方法与非静态方法讲解
package com.oop.demo01;

//Student类
public class Student {

    //非静态方法  不含修饰词static
    public void say(){
        System.out.println("学生说话了");
    }
}

//静态方法与非静态方法讲解
package com.oop.demo01;

public class Demo02 {
    public static void main(String[] args) {

        //当调用的方法中没有static时的非静态方法时，先实例化这个类 new一下
        //对象类型 对象名 = 对象值；
        Student student = new Student();//输入new Student();按回车 就可以了
        student.say();//这样就可以调用这个非静态方法了
    }
    //含有static的方法是和Demo02这个类一起加载的，是存在的
    public static void a(){
        b();
    }
    //发现上边调用方法b()出错了，因为没有static的非静态方法在类实例化之后才存在
    //而此时还没有new一下实例化b()，所以现在b()方法不存在 无法调用
    public void b(){

    }
}

---

//形参和实参 讲解
package com.oop.demo01;

public class Demo03 {
    public static void main(String[] args) {
        //实际参数和形式参数的类型要对应！
        int add = Demo03.add(1, 2);//输入Demo03.add(1,2);按回车
        System.out.println(add);//输出3

    }

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

---

//值传递（返回值传递）和引用传递
package com.oop.demo01;

//值传递（返回值传递）
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);//输出1

        Demo04.change(a);//把a=1放入change方法

        System.out.println(a);//输出1  因为下面的change方法没有返回值，没有把方法里的a=10返回出来，
        // 所以这里输出的a是前面的a=1，不是change方法里面的a=10

    }

    //返回值为void，即没有返回值
    public static void change(int a){
        a = 10;
    }
}

//引用传递：对象，本质还是值传递

//对象，内存
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 per){
        //per是一个对象：指向---> Person person = new Person();这是一个具体的人，可以改变属性
        per.name = "三三";
    }

}
//定义了一个Person类，有一个属性：name
class Person{
    String name;//null
}

this关键字后面再讲

---

---

P63 面向对象04：类与对象的创建

package com.oop.demo02;

//Student类
//类是抽象的，比如动物，衣服，房子，车子都是一类，并不具体指是猫或者狗或者奔驰车奥迪车等等
//一个类里面只包含 属性（字段） 和 方法 两种东西
public class Student {

    //属性：字段
    String name;//name里面是null 因为还没有给name赋值
    int age;//age里面是0，因为还没有给age赋值


    //方法
    public void study(){
        System.out.println(this.name+"在学习");//this指当前程序这个Student类，
        // this.name指当前这个类的name变量
    }
}

package com.oop.demo02;

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

        //类是抽象的，就像动物这个词也是类一样 并不知道具体指的哪种动物
        //所以需要把类实例化
        //类实例化后会返回一个自己的对象
        //下面的student就是对象，是一个Student类的具体实例！
        Student student = new Student();//输入new Student();按回车，这就叫做实例化了一个对象
        Student xiaoming = new Student();//这里产生的对象名可以任意编辑
        Student xh = new Student();
        //总结：Student类就像是一个模板或着说是一个模糊的大类，通过new这个关键词
        //     可以创建不同的实例xiaoming xh student 等等，而这些对象（xiaoming、
        //      xh student等等）都有Student类里面提供的各个属性（如Student类里面
        //      写的name、age属性等），我们可以给这些属性赋值（如xiaoming.name=" ",
        //       xiaoming.age=9 等等格式是 对象名.属性=某值）

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

        System.out.println(xiaoming.name);//小明
        System.out.println(xiaoming.age);//3

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

        System.out.println(xh.name);//小红
        System.out.println(xh.age);//3
    }
}
//学程序能对世界进行更好的认识和归类，争取出国！
//面向对象编程的本质：以类的方式组织代码，以对象的方式（属性）封装每个具体的数据

以上两个一个是主程序，一个是调用的类

---

---

P64 面向对象05：构造器详解

以下两个程序是一体的，一起看，一个是主程序，一个是被调用的类

package com.oop.demo02;

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

        //new 实例化了一个对象
        Person person = new Person();//这里通过new关键字调Person类中的无参数构造器，因为new Person()括号里没有东西，所以调用的是无参数构造器

        System.out.println(person.name);//zhangsan 因为我们改变了无参数构造器里面的默认值由null改为zhangsan，所以默认无参数输出zhangsan,
        // 一般情况输出null（不改默认值的情况下）


        Person person1 = new Person("lisi");//这里通过new关键字调Person类中的有参数构造器，因为new Person()括号里有东西是“lisi”，所以调用的是有参数构造器

        System.out.println(person1.name);//lisi

    }
}

package com.oop.demo02;

public class Person {

    //一个类即使什么都不写，它也会存在一个方法（也叫构造器或构造方法）
    //    （可以打开一个什么都不写的Java程序的class文件
    //      看看，里面有一个 public Java文件的类名（）{} 这样的方法

    String name;

    //写出一个class文件中的构造器，以这个Person类为例
    //显示的定义构造器
    public Person(){
        this.name = "zhangsan";//这个构造器是无参的
    }
    //说明：class中的构造器默认变量值为0或者null，这里我们把无参构造器从class
    //    文件中写出到Java文件中 并且把它的默认值null改为zhangsan

    //写一个有参构造器
    //一旦定义了有参构造器，无参构造就必须显示定义，否则在new的那个程序里会报错
    public Person(String name){
        this.name = name;
    }
    //有参构造器 在这个程序中叫 重载 ，因为这个程序里有两个方法名一样 参数变量不一样的构造器
    //重载：一个程序中，两个方法名字相同，参数变量不同，就叫做重载
}

//构造器作用：
//   1、在另一个程序中使用new关键字，本质是在调用 被调用程序类的 构造器
//   2、用来初始化对象的值
//   3、alt+ins  快速创建构造器
//构造器特点：
//     1、和类名相同
//     2、没有返回值
//注意：
//    1、定义有参构造之后，如果想使用无参构造，需要显示的定义一个无参的构造在Java程序中