Java中的类和对象

最新推荐文章于 2024-05-22 01:15:00 发布

一只猫๑

最新推荐文章于 2024-05-22 01:15:00 发布

阅读量198

点赞数 1

分类专栏：程序人生文章标签： Java 类和对象

本文链接：https://blog.youkuaiyun.com/HJY615main/article/details/102727392

版权

程序人生专栏收录该内容

27 篇文章

订阅专栏

一.类与对象的定义

类：类就是一类对象的统称，是结构体（高配版的。类的作用产生对象，一个类能产生多个实例对象，new 关键字用于创建一个对象的实例。语法示例：

class 类名{
  类体;
}

举例：

class Person {
    public String name=hjy; // name & age:属性/成员变量/实例成员变量
    public int age=20;
    
    
     // 行为/方法/成员方法（实例成员方法）
    public void eat() {
        int b = 10;
        System.out.println( name + "吃饭！");
    }
    public void sleep() {
        System.out.println( name +"睡觉！");
    }


     // 提供一个打印的show方法
    public void show();
       System.out.println("name:"+name+"age:"+age)
      
 
    public class Text{
    public static void main(String[] args) {
        // new：实例化一个对象
        Person person = new Person();
        person.show(); // 调用show方法
        person.eat(); // 调用eat
        person.sleep(); // 调用sleep
        // 执行结果：
           name:hjy age:20
           吃饭！
           睡觉！
        // 若想重新赋值(赋值后是新的对象)
         Person person = new Person();
         person.name="peggy";
         person.age=21;
         person.show(); // 重新调用show

         // 重复上述操作再产生新的对象
         Person person2 = new Person();

总结：实例化一个对象用：new；调用成员方法用person.成员名；不建议在定义成员变量的时候初始化，除非有特殊要求。
2. 类的成员：字段、方法、代码块、内部类和接口等。
字段：在类中, 但是方法外部定义的变量；
3. 对象：就是这一类具体化的一个实例，例：类–》模板，对象：–》实体
4. OOP：Object-oriented-program，面向对象程序设计语言。其三大特征：继承、封装、多态、。
5. 面向对象：处理大问题。
面向过程：处理小问题。
6. Java 是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成；C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

二. 静态成员变量&实例成员变量

成员变量是定义在类内部，方法外部。

static修饰的是静态成员变量。静态成员变量只有一份，放置在方法区。

public static int count=10;
public static final int SIZE=20;

final修饰的常量，也叫实例成员变量，放置在哪里不一定。

public final int SIZE1=30;

静态成员变量的访问，通过类名.属性进行访问；
实例成员变量必须通过引用访问。

// 静态成员变量
 public static void main(String[] args) {
 System.out.println(Person.count);
 System.out.println(Person.SIZE);

// 实例成员变量
public static void main(String[] args) {
Person person=new Person(); // 必须生成引用，才能通过引用去调用
System.out.println(Person.SIZE2);

所有的被static 所修饰的不管是方法，成员，他的调用或者访问都需要通过类名.属性 可以做到。也就是说，所有的被static所修饰的不管是方法，成员都不依赖于对象，存于方法区。

public static void func1() {
System.out.println("func1")

public static void main(String[] args) {
person.func1(); // 通过引用访问，会报警告。（小写）
Person.func1(); // 通过类名.方法访问。（大写）

※ 为什么 main 函数是 static静态的？
若main函数不是static的，则调用它：

public static Test {
   public void main(String[] args) {
      Test test=new Test; // 生成对象
      test.main();

该代码无法执行，因为此时main函数是一个普通的成员方法，若要调用它，必须进到main 函数里，而要进到main 函数里必须产生它所属的类Test 来生成一个对象，再通过对象的引用来调用main 函数。但若想产生对象，要进到main 函数里来，而现在无法进来，故该程序无法实现。所以main 函数必须由static 修饰，是静态的。所以说所有的被static所修饰的不管是方法，成员都不依赖于对象。

成员变量如果没有赋值，那么他的默认值就是自己所对应的零值。如果是引用类型–》null（引用类型：数组，类，String）；简单类型–》0 （char:’\u0000’ boolean: false）。
被static 修饰的变量和不被修饰的区别：

不被static修饰：（堆）

class Person {
    public int count;

public static Test {
   public static void main(String[] args) {
   Person person1=new Person();
   person.count++; 
   System.out.println(person1.count);
   Person person2=new person();
   person2.count++; 
   System.out.println(person2.count);
   // 执行结果：
      1
      1

被static 修饰：（方法区）

class Person {
    public static int count;

public static Test {
   public static void main(String[] args) {
   Person person1=new Person();
   Person.count++; 
   System.out.println(Person1.count);
   Person person2=new person();
   Person.count++; 
   System.out.println(Person2.count);
   // 执行结果：
      1
      2

产生该结果的原因是：
在这里插入图片描述
如图所示，当count 不被static 修饰时，count 存放在堆上，两次new 之后产生的对象不一样，所以出来的结果是各自的count++；而当count 被static修饰时，count 属于类，存放在方法区，不论有几个对象，方法区只有一个count，要不要new 的对象都行，两次count++是在同一个count上进行的。