回顾方法的定义：

package com.oop.demo01;

import java.io.IOException;

//Demo01 类
public class Demo01 {

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


    }

    /*
    修饰符 返回值类型 方法名字（...）{
        //方法体
        //return 返回值;
    }
     */

    //return 结束方法，返回一个结果
    public String sayhello(){
        return "hello,world";
    }

    public  void hello(){
        return;
    }
    public int max(int a,int b){
        return  a>b?a:b;
    }
    public void readFile(String file) throws IOException{
        
    }

}

回顾方法的调用：

1.静态和非静态方法

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

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

package com.oop.demo01;

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

        //非静态方法
        //实例化这个类
        //对象类型 对象名字=对象值
        Student student = new Student();

        student.say();
    }

    //和类一起加载
    public static void a(){

    }
    //类实例化 之后才存在
    public  void b(){}
}

形参和实参

package com.oop.demo01;

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

        int add = Demo03.add(1, 2);
        System.out.println(add);
    }

    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);
        Demo04.change(a);
        System.out.println(a); //1
    }


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

        Demo05.change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        //person是一个对象:指向的--> Person person=new Person();这是一个具体的人，可以改变属性
        person.name="貓";
    }
}

//定义一个person类  有一个属性 name
class Person{
    String name;
}

类与对象的关系：

学生类

package com.oop.demo02;

//学生类 类中最后不加main

public class Student {

    //属性：字段
    String name;//null
    int age;//0

    //方法
    public void  study(){
        System.out.println(this.name+"学生在学习");
    }
}

main

package com.oop.demo02;

//一个项目应该只存在一个main方法
public class Application {

    public static void main(String[] args) {

        //类是抽象的，需要实例化
        //类实例化后会返回一个自己的对象
        //student对象就是Student类的一个具体实例！
        Student student = new Student();
        Student xiaoming=new Student();

        xiaoming.name="xiaoming";
        xiaoming.age=12;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);
    }
}

构造器：

package com.oop.demo02;

public class Person {

    //一个类即使什么都不写 也会存在一个方法
    // 显示的定义构造器

    String name;
    //构造器能实例化初始值
    //1.使用new关键字，必须有构造器
    //2.用来初始化值
    //无参构造器
    public Person(){

        this.name="貓";
    }

    //有参构造器:一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name=name;
    }

    //alt+insert-------->自动生成有参和无参构造器
}
/*
//一个项目应该只存在一个main方法
public class Application {

    public static void main(String[] args) {

        //实例化对象
        Person person = new Person("貓");

        System.out.println(person.name);

    }

}
 */

/*
构造器：
1.和类名相同
2.没有返回值
作用：
1.new本质在调用构造方法
2.初始化对象的值
注意到：
1.定义有参构造后，必须定义无参构造
 */

创建对象内存分析：

package com.oop;

import com.oop.demo03.Pet;

//一个项目应该只存在一个main方法
public class Application {

    public static void main(String[] args) {

        Pet dog = new Pet();

        dog.name="wangcai";
        dog.age=3;
        dog.shout();

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


    }

}
/*
public class Pet {
    public String name;
   public int age;

    public void shout(){
        System.out.println("叫了一声");
    }
}

 */

小结：类与对象