Java的对象和类

  • 类：具有相同属性和方法的一组对象的集合，类是对象的抽象，对象是类的具体，类是一个模板，它描述一类对象的行为和状态。

  • 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。

    类的结构：

    一个类由属性和方法构成。
    局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
    成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
    类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

    创建类

    1. public class School {
    2.   //属性
    3.   String name;
    4.   String addres;
    5.   double area;
    6.   //方法
    7.   public void teach(){
    8.       System.out.println(addres+"的"+name+"可以"+"教书");
    9.   }
    10.   public  void  play(){
    11.       System.out.println(addres+"的"+name+"可以"+"玩");
    12.   }
    13. }

    创建对象

    1. //创建学校
    2.       School school=new School();
    3.       //给属性赋值
    4.       school.name="大学";
    5.       school.addres="沙坪坝";
    6.       school.area =10000;
    7.       //调用方法
    8.       school.teach();
    9.       school.play();

    无参方法有参方法

    1. //无参方法
    2. public void jia(){
    4.   }
    5. //有参方法
    6. public void jian(int a,int b){//实参
    8.   }
    9. //测试类
    10. Class cl=new Class() ;
    11.     cl.jian(2,3);//形参

    有返回值的方法：

    在定义方法是需要加入返回值如：int，double，，，在调用的方法中需要有一个变量来接收这个返回值。
    返回值的类型根据程序的需求来确定。

    1. public int get(int a,int b){
    2.       return a+b;
    3.   }
    4. //调用方法
    5. B B=new B();
    6. int B=B.get(a,b);

    Java方法中通过传递参数改变变量的值：

    基本数据类型，操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。引用数据类型（类、数组和接口），赋值是把原对象的引用（可理解为内存地址）传递给另一个引用
    1、对于基本类型参数，在方法体内对参数进行重新赋值，并不会改变原有变量的值。
    2、对于引用类型参数，在方法体内对参数进行重新赋予引用，并不会改变原有变量所持有的引用。
    3、方法体内对参数进行运算，不影响原有变量的值。
    4、方法体内对参数所指向对象的属性进行操作，将改变原有变量所指向对象的属性值。
    QQ图片20210412162013.png

    构造方法：

    构造方法特点：
    1.没有返回值，方法名和类名相同
    2.构造方法是用来创建对象的，参数必须一一对应
    3.无参构造系统自带，有参需要手动写出来
    4.当写了有参构造的时候，无参构造就不提供了，如果有需要就要 自己写出来
    每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。
    在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。 ```java public class Puppy{ public Puppy(){//无参构造方法 }

    public Puppy(String name){//有参构造方法 } }

  1. <a name="EubCD"></a>
  2. ### 方法的重载：
  4. - 同一个类中
  5. - 方法名相同
  6. - 参数个数或类型不同
  7. - 与返回值，访问修饰符无关（只看方法名参数，不看返回值和修饰符）
  8. ```java
  9.  public int StudenClass() {
  10.     int a;
  11.      return a;
  12.     }
  13. //方法重载
  14.     public int StudenClass(String name, int age) {
  15.         this.name = name;
  16.         this.age = age;
  17.         return this.age;
  18.     }

成员变量和局部变量的区别：

变量声明的位置决定变量的作用域
变量的作用域决定变量可以在程序中使用范围
QQ图片20210414112858.png

this关键字：

当成员变量与局部变量重名时，需要用this关键字来声明成员变量

封装：

将类的某些信息隐藏在内部，不允许外界程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
封装的优点
1. 良好的封装能够减少耦合。

  1. 类内部的结构可以自由修改。

  2. 可以对成员变量进行更精确的控制。

  3. 隐藏信息，实现细节。
    封装的分类：
    属性封装：
    1.属性改私有private
    2.创建公有的get/set方法
    3.对属性合法性增加判断
    方法的封装：
    涉及到代码设计

    访问权限修饰符

    QQ图片20210416134225.png

    static修饰符

    注意点：

  4. 只能定义在方法外面

  5. static方法只能使用static变量
  • 静态变量： ```java

public class Class2 { public static int money;} Class2.money=10000;

  1. static变量是所有对象共享的变量<br />static变量使用时应用类名直接调用，因为static变量不属于任何对象，属于类本身。<br />static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。<br />
  3. - **静态方法：**
  5. 用类名直接调用<br />static方法中不能使用this和super<br />static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
  7. - **静态代码块：**
  9. 在程序执行之前，就会优先执行<br />**变量的分类：**<br />成员变量：普通对象拥有<br />类变量（用static修饰的变量）：类拥有<br />局部变量：局部拥有<br />方法的分类：<br />成员方法：普通方法<br />类方法（用static修饰的方法）：类拥有
  10. <a name="cgJt9"></a>
  11. ## 特殊：
  12. this关键字：<br />动态对象，当前对象的意思<br />快捷键：<br />alt+enter：建议<br />alt+insert：自动生成代码<br />强行停止程序
  13. ```java
  14. System.exit(0);//强行结束程序