Java基础4-----类与对象

什么是java类

public class Test {
}

由class修饰符修饰的，xxx.java源文件就是java类

示例

public static void main(String[] args) {
        Student s=new Student();//创建Student类对象，对象名叫s

        //Student:数据类型：--------》规定数据在内存当中的存储形式
        //s:对象名/变量名
        //new关键字：要求在堆内存当中开辟内存空间
        //Student（）：构造器------》在创建对象的时候给对象赋初始值
        //=：赋值操作：是将堆内存当中创建的内存空间的地址赋给S变量
        Student s1=new Student();
        Student s2=new Student();
        //类是构建对象的模板，一个类可以创建多个对象，每个对象的数据的最初来源，来自类
        String name1=s1.name;
        System.out.println(name1);
        String name2=s1.name;
        System.out.println(name2);
//        int age1=s1.age;
//        System.out.println(age1);
//        int age2=s1.age;
//        System.out.println(age2);

    }

Student 数据类型:规定数据在内存当中的存储形式
s:对象名/变量名
new关键字：要求在堆内存当中开辟内存空间
Student（）：构造器------>在创建对象的时候给对象赋初始值
=：赋值操作，是将堆内存当中创建的内存空间的地址赋给S变量

类是构建对象的模板，一个类可以创建多个对象

每个对象的数据的最初来源于类

对象是类的实体

构造器：

构造器的作用：

创建对象并给对象赋初始值

示例

public class Student {

    public int age = 18;
    public String name = new String("张三"); // 使用 new 关键字创建 String 对象
    public char sex = '男'; // 提供一个默认值
    public double height = 1.75; // 使用 double 而不是 Double


    public void run() {
        System.out.println("学生跑得快");
    }
    public void fly(int num){
        System.out.println("学生能飞"+num+"米");
    }
}

public static void main(String[] args) {
        Student s=new Student();//创建Student类对象，对象名叫s

        //Student:数据类型：--------》规定数据在内存当中的存储形式
        //s:对象名/变量名
        //new关键字：要求在堆内存当中开辟内存空间
        //Student（）：构造器------》在创建对象瞬时给对象赋值
        //=：赋值操作：是将堆内存当中创建的内存空间的地址赋给S变量
        Student s1=new Student();
        Student s2=new Student();
        //类时构建对象的模板，一个类可以创建多个对象，每个对象的数据的最初来源，来自对象

        s1.name="李四";
        String name1=s1.name;
        System.out.println(name1);
        String name2=s2.name;
        System.out.println(name2);
//        int age1=s1.age;
//        System.out.println(age1);
//        int age2=s1.age;
//        System.out.println(age2);

    }

将s1的name值改为“李四”，s1和s2就是两个不同的实体

输出结果：

执行流程：

1.编写之后文件叫做xx.java文件，也称为源文件

2.通过javac的命令，将源文件编译成.class文件

3.通过java命令，将.class文件放到内存的方法区当中。

方法区用于存储类信息

4.main方法入栈

5.在main方法当中创建两个变量 s1,s2（对象名）

6.new关键字会在对内存当中开辟内存空间

7.将构造器中的变量和方法放到新开辟内存空间当中。

8.将内存空间的地址值，赋给变量

一开始输出值是相同的，原因：

类是创建对象的模板，一个类可以创建多个对象，每个对象的数据最初来源都是类，在最初始创建对象的时候，对象的信息均来源于类

后来输出结果不一致的原因：

s1.name="李四";

我们将s1所指向的内存空间，当中name变量的值改为“李四”

类和对象的联系：

类是创建对象的模板，而对象是真正意义上的实体。

什么是java对象

java对象指堆内存中的一块内存区域

Student s=new Student();的执行流程

首先main方法入栈，创建一个s变量，new关键字在内存中开辟一块内存空间，内存空间的值是由构造器所决定的，=将内存空间的地址值赋给变量

为什么java会设计对象？

因为类是构建对象的模板，一个类可以产生多个对象

变量的分类

局部变量：定义在方法中的变量

全局变量：定义在类当中的变量

面向过程VS面向对象：对数据的操作不同

面向过程的语言，在修改类的时候，会造成类当中的数据永久性改变，而面向对象的语言在修改时只会修改对象中的数据，不会修改类，具有一定的可修改能力

C语言 C++：面向过程的语言

面向过程的语言：通过方法，在方法内部操作类当中的变量

java：面型对象的语言

由类生成很多的对象，数据是存储在对象当中的，方法直接操作对象当中的数据

面向对象的语言：方法操纵对象当中的数据

示例

public class Student {

    public int age = 18;
    public String name = "张三"; // 使用 new 关键字创建 String 对象
    public char sex = '男'; // 提供一个默认值
    public double height = 1.75; // 使用 double 而不是 Double



    public void fly(double num){
        height=num;
    }

    public static void main(String[] args) {
        int hhhh=220;
    }
}

改变height值有两种方案

public class Test {
    public static void main(String[] args) {
        Student s=new Student();//创建Student类对象，对象名叫s
        Student s1=new Student();
        Student s2=new Student();
        s1.height=190.0;
    }
}

1.public double height = 175.0; 当height变量是public修饰的时候，可以通过 s1.height=190.0;直接进行修改

2..private double height = 175.0;当height变量是private修饰的时候，说明该变量是私有变量，无法直接对该变量进行访问，需要通过调用相关的方法

s1.fly(188.0);

方法直接操作对象当中的数据，但并不能直接操作类当中的数据

例题

public class Student {

    private double height = 185.0; // 使用 double 而不是 Double

    public double getHeight() {//获取当前的值
        return height;
    }

    public void setHeight(double height) {
        this.height = height;//设置值

    }
}

 public static void main(String[] args) {
        Student s=new Student();//创建Student类对象，对象名叫s
        Student s1=new Student();
        Student s2=new Student();
      s1.setHeight(188.0);
     System.out.println(s1.getHeight());
     System.out.println(s2.getHeight());

    }

程序执行流程：

1.main方法入栈

2.创建s1对象

3.开辟一块新的内存空间，内存空间中变量方法和列当中的一致

4.将新开辟的内存空间的地址值赋给s1对象

5.调用s1的setheight方法，

6.方法入栈，接受一个height类型的入参188.0（参数当作局部变量处理）

7.this.height = height;//设置值this代表当前对象，将入参的值赋给s1当中的height变量。

8.执行之后，方法出栈

9.s1的getHeight方法入栈

10.public double getHeight() {//获取当前的值

return height;

}返回全局变量height的值，进行输出

在整个过程中，我们一直在对对象当中的数据进行操作

堆存储对象，栈当中存储方法，方法区当中存储类信息

java对象的使用

示例

public static void main(String[] args) {
    Student s=new Student();//创建Student类对象，对象名叫s
    s.fly(3);
    s.run();

}

public class Student {

    public void run(){
        String name="123";
        System.out.println("学生跑的块");
    }

    public void fly(int num){
        System.out.println("学生飞的块");
    }


}

程序的执行流程

1.main方法入栈

2.创建一个student 类型对象s，指向新开辟的堆内存空间

3.堆内存空间当中有student类的方法

程序的执行流程就是方法的不断入栈出栈

4.fly()入栈，对局部变量num进行赋值，输出内容

5.fly出栈，run入栈，输出内容

基本数据类型：变量和和值放在一起

引用数据类型：变量是通过地址进行赋值的

6执行完成之后，.run出栈

用栈控制整个程序的执行流程

例题

public class Student {
   public int flag;
   public void run(){
       if(flag==1){
           System.out.println("此时flag=1");
       }else{
           System.out.println("此时flag等于其他值");
       }
   }
}

public static void main(String[] args) {
    Student student1=new Student();//创建Student类对象，对象名叫s
    Student student2=new Student();
    student1.flag=1;
    student2.flag=2;
    student1.run();
    student2.run();
}

程序的执行流程：

1.main方法入栈

2.创建变量student1，变量指向新开辟的内存空间0x1

3.student1对象当中有一个全局变量flag，默认值为0，还有一个run方法

int类型的默认值为0

4.创建变量student2，变量指向新开辟的内存空间0x2

5.student2对象当中有一个全局变量flag，默认值为0，还有一个run方法

6.student1.flag=1;

student2.flag=2

;

7.调用student1当中的run方法,进行判断，判断student1对象当中的flag值，进行输出

方法直接操作的是对象当中的数据

8.student1当中的run方法出栈

9.调用student2当中的run方法,进行判断，判断student2对象当中的flag值，进行输出

10.student2当中的run方法出栈