(JAVA) 类与对象

(JAVA) 类与对象(基础)

本章节开始了面向对象的程序设计方法。

目录

• (JAVA) 类与对象(基础)
• • 🐧一、类
  • 🦉二、对象
  • 🦆三、成员变量
  • 🦔四、成员方法
  • 🐘五、对象成员访问修饰符
  • 🐄六、可变参数
  • 🐿️七、方法重载
  • 🦬八、构造方法
  • 🐖九、静态成员
  • • 静态变量
    • 静态方法

🐧一、类

1. 一般，类是由成员变量和成员方法封装而成的。

2. 示例：

public class Cat {
    String name;
    public int age;
    double weight;

    void eat() {
        System.out.println(name + " is eating");
    }
    void play() {
        System.out.println(name + " is playing");
    }
}

使用关键字class来定义(声明)cat类。

cat是用户自定义的一种新数据类型，

name、age、weight都是cat类的属性

eat()和play()是cat类的方法

3. 类修饰符

   修饰符	含义
   public	声明一个公开的类，可以被任意对象访问
   省略	表明只有在相同包(同一目录）中的对象才能使用的类

   • 一个public修饰的类需要放在一个与类名相同的.java文件中。

   • 一个.java文件里可以有多个省略修饰符的类。

   • 当只有省略修饰符的类时，文件名可不与类名一致。每一个类都会加载出一个.class后缀的文件。

🦉二、对象

1. 使用类来创建对象。对象是类的实例化。

2. 示例：

Cat myCat = new Cat();
myCat.name = "梅茜"
myCat.eat();

这里打一个比方：将定义Cat类比作设计一个Cat的图纸。当你完成了图纸的设计，你也许会在图纸上详细的描述它会怎么吃，会怎么跑，应该有一个名字等等。但是这时它依旧只是一个图纸，并不能正在的跑。只有当你创建出它，即new Cat()实例化了一个对象，才能正在的让它跑起来(执行相应的方法)。
这就是我们想调用某个类的某个方法的时候，需要先实例化一个该对象的比喻的解释。

可以把对象理解为一种新型的变量

myCat是使用Cat类创建的对象

它保留着Cat类中初始化的数据，同时也可以修改自身的数据。

3. 使用： 对象名.对象成员

🦆三、成员变量

1. 成员变量又称属性或者是字段。可以是基本数据类型，也可以是引用类型。

2. String name = "小红";//引用类型
   public int age;//int型
   double weight;//double型
   

3. 成员变量：是在类中定义的、有修饰符、当创建(new)一个对象时，是对象的一部分，存放在堆内存，如果没有被赋初始值，会自动以类型的默认值赋值。

   局部变量：是在方法中定义的，无修饰符，存放在栈内存中，不会自动赋值，必须显示赋值后才能使用。

🦔四、成员方法

1. 成员方法，是对象成员的一部分，是类与外界进行交互的重要窗口。简称：方法。

2. 示例：圆柱体类Cylinder

public class Cylinder {
    double radius;
    double height;
    double area() {
        return 3.14*radius*radius;
    }
    double volume() {
        return area()*height;
    }
    public void setCylinder(double radius, double height) {
        this.radius = radius;
        this.height = height;
    }
}

在Cylinder类中，area()与volume()都是该类的方法。一个是算圆柱体的底面积，一个是算圆柱体的体积，返回类型为double。

可以发现在类定义里，某一方法可以直接使用本类的其他方法和成员变量。

setCylinder是用来给成员变量赋值的方法，调用该函数时需要传达参数，而参数double radius与double height是该方法的局部变量，并且与方法的成员变量重名。

this关键字表明是调用对象本身的成员。

因此this.radius是成员变量，而radius就是那个局部变量了（局部优先原则）。

3. 成员方法的返回类型可以是基本数据类型，也可以是引用类型。

🐘五、对象成员访问修饰符

访问控制修饰符

1. 修饰符	同类	子类	同包	不同包
   public(共访问控制符)	yes	yes	yes	yes
   protected(保护访问控制符)	yes	yes	yes	no
   省略(省略访问控制符)	yes	yes	no	no
   private(私有访问控制符)	yes	no	no	no

   根据你所定义方法的作用范围来选择以上四种修饰符

   同类：在定义该对象成员的类中，该类的其他方法可以访问该成员。
   子类：继承该类的子类中的方法可以访问该对象成员。
   同包：相同目录下其他文件中的方法可以访问该对象成员。
   不同包：不同目录下的文件中的方法可以访问该对象成员。

2. 使用：
   成员变量：[修饰符] 数据类型 成员变量名;
   成员方法：[修饰符] 返回值的数据类型 方法名( ){}

🐄六、可变参数

1. 在定义方法时，如果某一种类型参数可能多个，就可能用到可变参数

2. 示例：

public class Test {
    public static void main(String[] args)   {
        Test test = new Test();
        test.party(3,"小明","小红","小刚");
    }
    public void party(int n,String...name) {
        System.out.print("欢迎~");
        for (int i = 0; i < name.length; i++) {
            System.out.print(name[i] + " ");
        }
        System.out.println("参加第"+n+"届分享派对！！");
    }
}

3. 格式：

   返回值类型 方法名（固定参数列表，数据类型…可变参数名） {}

4. 细节
   *可变参数，传入的参数可以是0个或者多个。
   *实际上就是数组
   *如果方法中有多个参数，可变参数必须位于最后一项
   *只能有一个可变参数，(当然可以有多个数组参数)。

🐿️七、方法重载

方法重载是实现多态的方法之一。

1. 在同一个类中，有多个相同方法名，不同形参列表的方法，就是方法的重载。

2. 示例：

public class test {
    public static void main(String[] args)   {
        until until = new until();
        int x = 105;
        char x2 = '风';
        until.printf(x);
        until.printf(x2);
        until.printf();
    }
}
class until {
    void printf(int x) {
        System.out.println(x);
    }
    void printf(double x) {
        System.out.println(x);
    }
    void printf(char x) {
        System.out.println(x);
    }
    void printf() {
        System.out.println("null");
    }
}

上述示例中我们也行可以发现其实System.out.println()中的println()也用到了方法重载。

3. 注意：对于方法重载
   方法名必须相同，形参列表必须不同，返回类型无要求

🦬八、构造方法

1. 在前面成员方法示例中的Cylinder类有一个setCylinder()方法用来给该类的成员变量赋值，如果能够在创建对象的时候就完成初始化，程序会更加优化。java提供了一个特殊的成员方法——构造方法。

2. 示例：

public class Test {
    public static void main(String[] args)   {
        Cylinder c1 = new Cylinder();
        Cylinder c2 = new Cylinder(1.3);
        Cylinder c3 = new Cylinder(1.2, 10);
    }
}
class Cylinder {
    double radius;
    double height;
    Cylinder() {
    }
    public Cylinder(double radius) {
        this.radius = radius;
    }
    public Cylinder(double radius, double height) {
        this.radius = radius;
        this.height = height;
    }
}

可以发现没有public Cylicder(double height){}的构造方法，这是因为和方法重载类似，需要有不同的参数列表，即当两个构造方法的参数列表都为double型时，会出现重定义错误。

3. 构造方法的注意：

   • 方法名要与类名一样
   • 无返回值。是因为加了返回值就变成普通方法了。
   • 一般不能显示的调用，而是通过创建（new）一个对象的同时由系统自动调用，
   • 也有public、省略、protect、private等修饰符

4. 默认构造方法。

   在其他的类中，我们其实并没有定义构造方法，但是在创建对象的时候，编译器会自动为该类生成一个默认的构造方法，对于Cat类，它的默认构造方法就是：Cat(){}。如果是public Cat类，会生成public Cat(){}的默认构造方法。

   一旦用户自定义了构造方法，系统就不会提供默认构造方法。 需要自己定义一个无参的构造方法。

5. 当你在初始化化对象的时候需要一个默认值，而不是初始值。可以在该无参构造方法里来调用有参构造方法

public Cylinder() {
    this(1,1);
}

this(1,1)中有两个参数，都为整型数据，系统会自动匹配到第三个构造方法public Cylinder(double radius, double height)，毕竟int可以自动类型转换为double。

注意：在某一构造方法中调用另一构造方法，必须用this()语句来调用，且必须为该构造方法的第一条语句。

🐖九、静态成员

被static所修饰的对象成员称为静态成员。

静态变量

1. 用static修饰的成员变量，叫做静态变量、静态属性或类变量。

2. 示例：

public class test {
    public static void main(String[] args)   {
        Dog.cName = "犬";//对于静态变量,可以不用创建一个对象就可以直接访问
        Dog d1 = new Dog("旺柴");
        Dog d2 = new Dog("富贵");
        System.out.println(d1.name+"是"+d1.cName);
        System.out.println(d2.name+"是"+d2.cName);
    }
}
class Dog {
    static String cName;
    String name;
    int age;
    public Dog(String name) {
        this.name = name;
    }
}

3. *对于类的所有对象，静态变量是他们公共的区域。
   *可以不用创建(new)一个对象就可以访问。

4. 使用：*类名.静态变量名 （推荐）
   *对象名.静态变量名

静态方法

1. 用static修饰的成员方法，叫做静态方法或类方法。

2. 示例：

public class test {
    public static void main(String[] args)   {
        double radius = 2;
        System.out.println("半径为"+radius+"的圆的面积为"+
                math_.areaCircle(radius));
    }
}
class math_ {
    static double pai = 3.1416926;
    static double areaCircle(double radius) {
        return pai*radius*radius;
    }
}

3. *静态方法属于该类的所有对象。因此不能在静态方法里直接使用属于某个对象的成员。
   *静态方法中也不能使用和对象有关的关键字,如this、super

示例：

class try_ {
    static int a;
    int b;
    static void way1() {
        System.out.println(a);
        way1();
//不能直接使用对象成员
//        System.out.println(b);
//        way2();
//如果需要使用可以通过创建对象的方法简介访问
        try_ t = new try_();
        System.out.println(t.b);
        t.way2();   
    }
 //普通方法无限制，可见上文 四、成员方法
    void way2() {
        System.out.println(a);
        System.out.println(b);
        way2();
        way1();
    }
}

4. 对于一些方法，加上static变成静态方法，也许就是为了不创建对象，就能使用。

   当然也有两种调用方式：类名.静态方法名(); 或 对象名.静态方法名();

5. 细心的小伙伴可以发现，在2.的示例中，test类也有一个静态方法，即main()方法。其实main()方法是由虚拟机调用的，因此需要的访问权限是public，并且不需要创建对象，因此用static修饰。

待续~