Java中类，对象，方法的关系

类

1. 类的理解

• 类是现实生活中一类具有共同属性和行为的事物的抽象
• 类是一个抽象的概念，它不存在于现实中的时间/空间里，类只是为所有的对象定义了抽象的属性与行为
• 自我理解就是: 1.将张三这个人（对象）拥有的行为（吃饭，睡觉）和拥有的属性（名字，身高）抽象出来变成一个更大的集体（类），类可以理解为现实生活中所说的 “类型”，，也就是说张三具有这个集体的一些行为和属性，这个集体具体描述的一些行为就是方法.
  2.可以把类理解成一个对象的抽象，这个抽象的对象包含了变量（用来描述这个对象的属性）和方法（用来描述这个对象可以干什么），类中的各个成员之间可以相互调用（static修饰的成员不能访问没有static修饰的成员）.
  3.而每个类中又必须有一个或者多个构造方法，这个构造方法用来将这个抽象的对象实例化。

2. 类的定义步骤

public class 类名{
//成员变量
int weight=100
…
//成员方法
修饰符 返回类型 方法名（参数类型 参数名） {
执行语句
return 返回值
}
public void eat(){
System.out.println(“吃饭”)；
}
}

3. 类的性质

类的三大特性

• 封装性
  将数据和操作封装为一个有机的整体，由于类中私有成员都是隐藏的，只向外部提供有限的接口，所以能够保证内部的高内聚性和与外部的低耦合性。用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员，能够增强安全性和简化编程。
• 继承性
  继承性更符合认知规律，使程序更易于理解，同时节省不必要的重复代码。
• 多态性
  同一操作作用于不同对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向父类（基类）的指针，来调用实现子类（派生类）中的方法

方法

1. 方法的定义

//成员方法

1. 修饰符 返回类型 方法名（参数类型 参数名） {
   执行语句
   return 返回值；
   }
   public void eat(){
   System.out.println(“吃饭”)；
   }
2. 对于上面的语法格式中具体说明如下：
   1）修饰符：方法的修饰符比较多，有对访问权限进行限定的public，private，protect，有静态修饰符static，还有最终修饰符final等
   2）返回值类型：用于限定方法返回值的数据类型
   3）参数类型：用于限定调用方法时传入参数的数据类型
   4）参数名：是一个变量，用于接收调用方法时传入的数据
   5）return关键字：用于结束方法以及返回方法指定类型的值
   6）返回值：被return语句返回的值，该值会返回给调用者
3. break与return的区别：
   break:跳出switch结束循环
   return：方法结束，之后写的语句无效
4. 抛出异常…

2. 方法的调用

1. 静态方法调用

• 静态方法就是用static修饰的方法，静态方法的调用是通过类名来调用的也可以通过对象来调用，格式如下
  类名.方法名（）；
• 如果用静态方法调用非静态方法只能通过实例化类通过对象调用

//学生类
public class Student(){
          //静态方法
     public static void say(){
           System.out.println("说话");
  } 
}
//测试类
public class Test(){
 public static void main (String[] args){
         Student.say()
   }
}

2. 非静态方法的调用

• 非静态方法就是没有用static修饰的方法，非静态方法的调用是通过对象来调用的，格式如下:
  对象名.方法名（）；
• 非静态方法调用静态方法可以通过类名来调用的也可以通过对象来调用

//学生类
public class Student(){
         //非静态方法
     public void say(){
           System.out.println("说话");
  } 
}
//测试类
public class Test(){
 public static void main (String[] args){
   /*
   我们需要实例化这个类（得到一个对象）
   格式：类名 对象名 = new 类名();
   */
     Student student = new Student();
       student.say();
     
     
   }
}

3. 类中方法调用方法

• 下列代码中方法a和方法b之间可以直接调用,方法c和方法d之间也可以直接调用说明在同一个类中静态方法可以直接调用静态方法，非静态方法可以直接调用非静态方法，但是两个静态或者非静态方法之间不能相互的去调用（就是不能在方法a中调用方法b再在方法b中调用方法a）
• 非静态方法也可以直接调用静态方法，列如下面代码方法b可以直接调用方法c
• 静态方法不能直接调用非静态方法，列如下面代码中不能用方法d直接去调用方法a，但是可以实例化Test类，通过对象来调用（因为用static修饰的方法是和类一起加载的，而非静态方法是在类实例化后加载的）

public class Test(){
//类实例化后加载的
  public  void a(){
     b();
  }
  public  void b(){
     c();
  }
  //和类一起加载的
  public static void c(){
       d();
       
  }
  public static void d(){
  //a();这是不行的
  Test test = new Test();
     test.a();
  }

}

总结下来就是：

• 1.）在同一个类中静态方法可以直接调用静态方法，通过实例化对象调用非静态方法
  原因是因为用static修饰的方法是和类一起加载的，而非静态方法是在类实例化后加载的
  2.）在同一个类中非静态方法既可以直接调用静态方法和非静态方法也可以用通过实例化调用调用静态方法和非静态方法
• 1.）在不同的类中静态方法可以通过类名.方法名或对象名.方法名调用另一个类中的静态方法，只能通过实例化对象调用非静态方法
  2.）在不同类中非静态方法可以通过类名.方法名或对象名.方法名调用另一个类中的静态方法，只能通过实例化对象调用非静态方法

3. 方法的形参和实参

形式参数与实际参数的数据类型要一致才能将实参传给形参

public class Test(){
 public static void main (String[] args){
    int result=Test.add(1,2);//实际参数
     System.out.println(result);
 }
   public static int add(int a,int b){//形式参数
          return a+b;
  }
  //输出结果为 3

4. 值传递和引用传递

值传递：传递对象的一个副本，即使副本被改变，也不会影响源对象，因为值传递的时候，实际上是将实参的值复制一份给形参

//值传递
//
public class Test(){
 public static void main (String[] args){
      int a=1;//实际参数
      System.out.println(a);//输出1
      Test.add(a);
      System.out.println(a);//输出还是1
 }
 //这里返回值为空
   public static void add(int b){//形式参数
         b=100;
  }
 }

引用传递：传递的并不是实际的对象，而是对象的引用，外部对引用对象的改变也会反映到源对象上，因为引用传递的时候，实际上是将实参的地址值复制一份给形参。

//引用传递 对象，本质还是值传递
public class Demo3 {
    public static void main(String[] args) {
        Human man=new Human();
        System.out.println(man.name);
        change(man);
        System.out.println(man.name);
        
    }
                                    //这个只是一个变量名
    public static void change(Human woman){
      woman.name="李四";
      //对象.name
    }
}
//定义了一个human类，具有name这个属性
class Human{
    String name="张三";
    //属性：字段
}

//对比上面的值传递发现相当于是woman=man，b=a
//下面的woman.name等与man.name
//上面的值传递也是b=a
//那为什么上面值传递b值改变不影响a值
//下面woman.name的改变影响了man.name呢？
//这是因为上面值传递中b只是形式参数，只在方法add中存在，b指向的只是a的地址，b和a都只是一个属性，所以b值改变不会影响a值
//而下面引用传递中man这个对象指向的是这个huamn类型的woman（只是一个名字，相当于int a，一个int类型的a），就是woman从一个数据类型变成了一个对象
//值传递是把同类型的字段进行传递，引用传递是把对象传给一个类型

对象

1. 什么是对象

• 对象是人们要进行研究的任何事物，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。对象具有状态，一个对象用数据值来描述它的状态。对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。对象实现了数据和操作的结合，使数据和操作封装于对象的统一体中。
• 对象就是类的具体实例

2. 什么是面向对象？

• 面向对象编程的本质就是：以类的方式组织代码，以对象的形式封装数据
• 面向过程：了解面向对象前，先了解面向过程。我们之前所编写的程序都是面向过程的，分析解决问题的步骤，然后按照步骤第一步做什么，第二步做什么…如果将步骤写成了方法，就依次调用方法。适合处理简单的问题。
• 面向对象：而面向对象是一种抽象的分类的思想，分析解决问题需要从哪几个方面出发，即有哪几个分类，然后对这些分类进行单独的面向过程的思考，每一个分类需要具体的完成什么。用于处理复杂的问题。

例：

• 面向过程：建房子需要先打地基…一步一步往上做
• 面向对象：现在要建一栋房子，这就更复杂了，首先需要分为三大类，需要设计人员设计图纸，需要建筑人员建房子，需要装修人员装修；而设计人员怎么设计图纸，建筑人员怎么建造，装修人员怎么装修又是每一个分类的具体细节。

3. 如何创建对象

• 通过new关键字来创建对象
  类名 对象名=new 类名();
• 使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用