java类中的构造方法

Ⅰ 什么叫做java的构造方法（含义）

在Java中，每个类都需要至少一个的构造方法（可以有多个），它用于构造类的对象；在Java中构造方法必须与类名相同；构造方法可以不带有参数、也可以带有参数，不带有参数的构造方法被称为无参构造（no-arg）方法。

这里大家可能会觉得奇怪，我们之前的MainClass好像就没有构造方法。其实是这样的，如果我们不给类提供构造方法，编译器会自动提供一个无参构造方法。

定义构造方法的语法如下：

Java代码
constructorName (listOfArguments) {
[constructor body]
}
其中constructorName必须和你定义的类的名字相同，listOfArgumengs是构造方法的参数列表，当然，这里也可以不带有任何参数。然后大括号内是我们的方法体。这里提一下，构造方法也可以带有访问控制符，即public、protected、private和default（忽略情况下）。

下面的例子给出了一个构造方法的实例：

Java代码
public class MainClass {
double radius;

// Class constructor
MainClass(double theRadius) {
radius = theRadius;
}
}
可以看出，我们给MainClass定义了一个构造方法，它的修饰符是默认的。后面的教程大家会学到这几个访问控制符的作用。我们的MainClass的构造方法带有一个double参数，这里大家也可以看出，构造方法的参数可以用于初始化类的属性，其实强制要求带参数的构造方法可以保持类的状态的完整性，即保证构造出的对象是符合要求的。

默认构造方法
前面我讲过，如果没有提供构造方法，编译器会提供一个默认的构造方法（没有参数）。这里其实也隐含着一个意思，即，如果我们提供了构造方法，那么编译器是不会提供默认的构造方法的。我们可以通过下面的代码来验证。

Java代码
public class MainClass {
double radius;

// Class constructor
MainClass(double theRadius) {
radius = theRadius;
}

public static void main(String[] args) {
MainClass mc = new MainClass();
}
}
大家可以尝试编译上面的代码，可以发现编译会出错，提示的错误信息为：

Java代码
The constructor MainClass() is undefined
这个信息的意思是构造方法MainClass()没有定义，即编译器没有给我们提供默认的构造方法。那么如果我们还想继续使用无参的构造方法的话，这就需要我们自己来提供了，如：

Java代码
public class MainClass {
double radius;

MainClass() {

}

// Class constructor
MainClass(double theRadius) {
radius = theRadius;

}

}
上面的代码我们自己手动的提供了一个无参的构造方法MainClass()，大家现在尝试编译代码，会发现，代码是可以通过编译的。所以在自己实际的工作中，稍微注意这点。

多个构造方法
其实我们前面已经见过多构造方法的例子了，不过这里给大家提示下，Java支持一个类中定义多个构造方法，如：

Java代码
class Sphere {
int radius = 0;

Sphere() {
radius = 1;
}

Sphere(int radius) {
this.radius = radius;
}
}
这里我们定义了球（Sphere）类，然后定义了它的半径并提供了两个构造方法。在默认的构造方法里，我们将半径设置为1，然后在带有半径作为参数的构造方法中，我们设置了半径为提供的值。

在一个构造方法中调用另一个方法
我们一直称呼构造方法，那么既然是方法，当然支持方法的调用。在Java中，我们可以从一个构造方法中调用另一个构造方法。要调用另一个方法，只要使用this关键字，然后后面跟着括号，如果要调用的构造方法中带有参数，只要将参数放到对应的位置即可。如：

Java代码
class Sphere {
int radius = 0;
double xCenter;
double yCenter;
double zCenter;

Sphere() {
radius = 1;
}

Sphere(double x, double y, double z) {
this();
xCenter = x;
yCenter = y;
zCenter = z;
}

Sphere(int theRadius, double x, double y, double z) {
this(x, y, z);
radius = theRadius;
}
}
在使用这种方式的时候，稍微注意下，不要引起循环调用。在出现循环调用的时候，编译器会出现类似于如下的提示来阻止类编译通过：

Java代码
Recursive constructor invocation MainClass(int)
它的意思是递归的构造方法调用，大家遇到这个问题的时候，稍微检查下自己的代码，看看构造方法是否出现递归调用了。

Ⅱ Java类的构造方法，怎么

你搏帆这里构造方法调用其他构造方法，不能这么用。可以用this关神圆键字去代替。
public Student(String name, int id){
this(name); //调用本类一个参数的构造方法。 用this调用其基瞎雹他的语句，必须要放在构造函数中的第一个语句。
this.id = id;
}
public Student(String name){
this.name = name;
}

Ⅲ java 类 构造方法

PublicclassHero{
privateStringname;
Privateintattack;
Privateinthp;
Privateintmp;
Privateintspeed;
//构造方法
publicFather(Stringname,intattack,inthp,intmp,intspeed){
李差this.name=name;
this.attack=attack;
哪滑皮this.hp=hp;
this.mp=mp;
this.speed=speed;
}
}

publicclassHeroesextendsHero{
	privateStringskill;
	//构造方法
	publicHeroes(Stringname,intattack,inthp,intmp,intspeed,Stringskill){
		super(name,attack,hp,mp,speed);
		this.skill=skill;
	}
	//测试
	publicstaticvoidmain(String[]args){
		Heroesh1=new让纤Heroes("剑圣",250,2500,0,530,"高原血统");
		Heroesh2=newHeroes("蛮子",350,2500,0,470,"无尽的怒火");
	}
	
}


哥们你这是瞎搞啊我纯手给你打的望采纳吧

Ⅳ java中构造方法有哪些条件一般什么时候被调用

构造方法是类中比较特殊液隐大的方法、它有如下几个特点
1.方法没有返回值
2.方法名和类名相同
3.构造方法可以重载(包括参数类型不同的重闹竖载和参数个数不同的重载)
4.每个类默认会有一个无参的构造函数
例：携明
public Class User{
public User(){}
public User(String name,int age){
this.name = name;
this.age = age;
}
private String name;
private int age;
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}

public int getAge(){
return this.age;
}

public void setAge(int age){
this.age = age;
}

}

构造函数是在你New对象的时候被调用的
例: User user = new User();

Ⅳ java中什么是构造方法及其作用

无意中翻到这条提问,看了很多回答,发现歧义较重,在这里解答一下,为了避免后边来的朋友们踩雷
新手学习Java在构造方法这里很容易踩雷,构造方法是用来初始化的,这句勉强没错,可构造方法是用来创建对象的,这句就错了,实际上,在构造方法执行之前,类的内存空间已经开辟完成了,意思就是说对象已经创建了,这步是由new关键字来完成的,而构造方法的作用是给类中的变量进行初始化赋值
假设,假设构造方法是用来创建对象用的,就无法解释抽象类中为什么允许构造方法的存在,抽象类无法实例化,不能被创建,但是抽象类中允许构造方法的存在,举例从侧面证明一下:
abstract class Animal{
String name;
public Animal() {
System.out.println("抽象父类的无参构造");
}
abstract void eat();
}
class Dog extends Animal{
public Dog() {
super();
System.out.println("子类的无参构造");
}
@Override
void eat(){

}
}
public class Test {
public static void main(String[] args) {
Dog d = new Dog();
System.out.println(d.name);
}
}
随手敲的很简陋的一段代码,不要在意格式上的不严谨,领会精神,这段代码执行后的结果为:
抽象父类的无参构造
子类的无参构造
null

当执行Dog d = new Dog()这句代码时,大致会分两步,一是加载类,开辟类的内存空间,这是由new完成的,第二步执行构造方法,为类中的变量初始化赋值,在执行Dog的无参构造时,系统会默认调用父类的无参构造,也就是super(),super关键字是对该类的父类进行的引用,它并不是一个对象,这也是个难点,感兴趣的可以去查一下,而super()这句代码可以简单理解为调用这个类的父类的无参构造
在上述代码中,父类Animal是一个抽象类,而抽象类不可被实例化,如果构造方法的作用是创建对象,在这一步上逻辑就无法自洽,而实际情况是:抽象类执行了构造方法,但却没有创建对象,同时成员变量name也有了初始值null

Ⅵ java中什么叫构造方法

构造方法是一种特殊的方法，与一般的方法不同是：
1.构造方法的名字必须与定义他的类名完全相同，没有返回类型，甚至连void也没有。
2.构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象。
3.不能被static、final、synchronized、abstract和native修饰。构造方法不能被子类继承。

class RectConstructor{
double length;
double width;
double area(){
return length*width;
}

//下面这个方法就是所谓的构造方法，没有返回值，方法名与类名相同~~~
RectConstructor(double width,double length){//带参数的构造方法
this.length=length;
this.width=width;
}
}
其实构造方法就是为了给类中成员赋初值~~~~~~~~~~~~~

Ⅶ JAVA构造方法

1. 构造方法的方法名必须与类名一样。

2. 构造方法没有返回类型，也不能定义为void，在方法名前面不声明方法类型。

3. 构造方法不能作用是完成对象的初始化工作，他能够把定义对象时的参数传递给对象的域。

4. 构造方法不能由编程人员调用，而要系统调用。

5. 构造方法可以重载，以参数的个数，类型，或排序顺序区分。

   例子：

   1；单个构造函数方法；’
   

Ⅷ 请问java中，构造方法是什么 能通俗的讲讲吗

首先要搞清楚什么是类方法，什么是构造方法
一个类中的方法分为三类：
1）全局方法 2) 成员方法 3）构造方法
例：
123456789101112public class Test{private int age; //这是成员变量public Test(int age){ //这是构造方法this.age = age;}public void setAge(int age){ //这是成员方法this.age = age;}public static int getAge(){ //这是全局方法，加了static ，成员方法就会变成全局方法return this.age;}}
成员方法和构造方法没啥关系，区别在于成员方法必须用类的实例化对象进行访问，而全局方法是用类直接访问的，而构造方法是实例化对象时进行初始化的

先解释构造方法：
Test t = new Test(34);
这里的new Test(34) 括号代表了构造方法，一般的构造的方法是默认的，可以不用写，如果上面的构造方法不写，这里就应该这样实例化对象：
Test t = new Test();

成员方法：
Test t = new Test(34);
t.setAge(35);
用实例化对象调用普通方法即可

普通成员变量:
Test t = new Test(34);
因为变量age加了private 不能这样调用：t.age = 35; 这样是错的，只能通过方法来进行修改

全局方法：
Test.getAge();
直接这样调用就可以了，当然如果没有实例化过，这里的Test.getAge()为0

Ⅸ JAVA中构造方法和普通方法的区别

JAVA中构造方法和普通方法的区别 1.建构函式的命名必须和类名完全相同;在java中普通函式可以和建构函式同名，但是必须带有返回值。
2.建构函式的功能主要用于在类的物件建立时定义初始化的状态.它没有返回值,也不能用void来修饰.这就保证了它不仅什么也不用自动返回,而且根本不能有任何选择.而其他方法都有返回值.即使是void返回值,尽管方法体本身不会自动返回什么,但仍然可以让它返回一些东西,而这些东西可能是不安全的.
3.建构函式不能被直接呼叫,必须通过new运算子在建立物件时才会自动呼叫,一般方法在程式执行到它的时候被呼叫.
4.当定义一个类的时候，通常情况下都会显示该类的建构函式,并在函式中指定初始化的工作也可省笑烂帆略，不过Java编译器会提供一个预设的建构函式.此预设建构函式是不带引数的.而一般方法不存在这一特点
java中构造方法和普通方法的区别
构造方法：一个类 被例项化 也就是被new的时候 最先执行的是 构造方法，在java类中，如果不显示宣告建构函式，JVM 会给该类一个预设的建构函式。一个类 可以有多个建构函式。建构函式的主要作用 一是用来例项化该类。二是 让该类例项化的时候执行哪些方法，初始化哪些属性。当一个类声明了建构函式以后，JVM 是不会再给该类分配预设的建构函式。
其实建构函式是用来对一个类以及变数进行例项化。
JAVA中构造方法和普通方法的区别是什么？
只有构造方法才能new，用于生成例项物件，分配记忆体空间等。
普通方法是不能new 的，可以通过物件名来呼叫。在物件有记忆体空间后可以处理类成员变数和呼叫其他的方法。
拿个不算恰当的比喻来说，
构造方法相当于给你开房间，普通方法是进房间后在自己的许可权内随便玩，设定可以开另外一个房间。没有房间之前，历辩普通方法无用武之地。
java构造方法和普通方法的区别
构造方法没有返回值，普通方法有返回值，构造方法在类的物件被建立时执行，普通方法在类的物件建立后呼叫时被执行
java中的构造方法和普通方法的区别
构造方不能写返回值型别
构造方法是用来例项化物件的有有参的有无参的

Java 普通方法和构造方法的区别
构造方法:
①方法名和 类名相同
②在方法名的前面没有返回值型别的宣告
③在方法中不能使用return语句返回一个值
④在建立物件时碰雹，要呼叫new，如:book b1=new book();
⑤当没有指定构造方法时，系统会自动新增无参的构造方法
⑥当有指定构造方法时，无论该构造方法是有参，还是无参，系统都不会再自动新增无参的构造方法
⑦构造方法的过载：方法名相同，但引数不同的多个方法，呼叫时会自动根据不同的引数选择相应的方法
无参的构造方法
class person{
public person(){
System.out.println("无参的构造方法被呼叫了。。。");
}
}
class Ex11{
public static void main(String[] args){
person p=new person();
}
}
有参的构造方法（目的就是为了给物件例项变数赋值）
class person{
int age;
public person(int a){
age=a;
}
public void speak(){
System.out.println("I am "+age+" years old");
}
}
class Ex11{
public static void main(String[] args){
person p=new person();
p.speak();
}
}
普通方法有返回型别，方法名小写，不能和类名相同，如:void XX(){}普通方法：代表物件可以干什么
构造方法是初始化物件的重要途径，如:student s=new student(); s这个例项，是通过构造方法初始化的构造方法：可建立一个物件，并可初始化物件的值
构造方法有对类属性得初始化的功能，如:public people(String name){this name=name;}或public people(){name="zangsan";age=11;} 完成了people类属性name或age的初始化
php构造方法析构方法和普通方法的区别
有的类，需要进行一些初始化，比如赋初值、预设值，为类成员申请临时空间，这些工作可以在建构函式中完成；解构函式可以将建构函式中申请的临时空间释放，也可以逐一检查类中成员如果申请了临时空间也一一释放。
java中构造方法和方法的区别
1.建构函式的命名必须和类名完全相同;在java中普通函式可以和建构函式同名，但是必须带有返回值。 2.建构函式的功能主要用于在类的物件建立时定义初始化的状态.它没有返回值,也不能用void来修饰.这就保证了它不仅什么也不用自动返回,
java中构造方法和成员方法的区别
构造方法是类的一种特殊方法，用于例项化类时给类的一些属性赋初值；成员方法则是类的一般方法，用来呼叫的。

例如：
public class Users{ private String username; private String password; public Users(){ Users的空构造方法 } public Users(String name,String password) { Users的第二种构造方法给使用者名称和密码赋值 this.username=name; this.password=password; } 以下是一般的成员方法给使用者名称和密码set赋值及get获取 public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public static void main(String[] args){ 接下来利用构造方法例项化类,构造方法一 Users u= new Users(); System.out.println("使用者名称："+u.username); System.out.println("密码："+u.password);可以看到是空值 使用构造方法二 Users u= new Users("zhangsan","123456"); System.out.println("使用者名称："+u.username); System.out.println("密码："+u.password);可以看到使用者名称是zhangsan，密码是123456 使用一般方法 u.setUsername("lisi") u.setPassword("654321") System.out.println("使用者名称："+u.getUsername()); System.out.println("密码："+u.getPassword());可以看到使用者名称是lisi，密码是654321 }
｝
Java中static方法和普通方法的区别
static方法就是静态方法。
静态方法是类方法，类名即可引用。
普通方法是物件方法，需要例项化物件才可以引用

Ⅹ JAVA中构造方法，例项方法，类方法，有什么区别

JAVA中构造方法，例项方法，类方法，有什么区别？

构造方法：构造方法是用来构造类的物件的，方法名和类名相同没有返回值。一般用 new 构造方法名() 来建立该类的物件。在不写构造方法的情况下会有一个预设的无参构造方法，当然你也可以重写和过载构造方法（建议你找一本《Java程式设计思想》看看，里面讲的很透彻）。
例项方法：简单地说就是可以通过类的例项（某个物件）呼叫的方法，也就是我们正常情况下使用的方法。例项方法也称成员方法（成员方法和成员变数的知扒袭识你可以参考《Java程式设计思想》）。
类方法：简单地说就是直接可以用类名呼叫的方法，也就是被关键字static修饰的方法，它不需要建立类的物件来呼叫该方法。（关于static关键字的详细用法你也可以在《Java程式设计思想》这本书中找到）。
《Java程式设计思想》是目前最好的Java参考书，网上有第3版的中文版电子书下的，第4版是英文的

Java中的构造方法与例项方法，有什么区别？

java中所谓的构造方法是指JAVA虚拟机器在LOAD载入这个类的时候，利用构造方法来建立这个类的一个例项所呼叫的方法，典型的就是构造方法的过载
public class student{
private int id;
private String name;
private int age;
以 *** 现出构造方法的过载
public void student() {}
public void student(int id ,String name) { this.id=id; this.name= name;}
public void student(int id ,String name,int age) {this.id=id; this.name=name; this.age=age;}
}
呼叫方法是指已经在类库中写好的方法我们直接去呼叫就可以了，如：System.out.println();
至于例项方法可以理解为类的中普通方法，就是我们在类中自己建立定义的。

行为差异：构造方法，建立物件后自动呼叫构造方法，例项方法必须物件.例项方法进行呼叫。
功能差异：构造方法多用于初始化物件状态，对属性赋初值，例项方法用于实现某个功能

java中构造方法和方法有什么区别

我不知道怎么和你解释，所以在网上找了点资料，希望可以帮助你。
构造方法要与类名相同，无返回型别，在类初始化的时候呼叫。
方法最好与类名不同，物件呼叫，静态方法可用类名.方法（）.
功能和作用的不同
构造器是为了建立一个类袭则的例项。这个过程也可以在建立一个物件的时候用到：Platypus p1 = new Platypus();
相反，方法的作用是为了执行java程式码。
修饰符，返回值和命名的不同
构造器和方法在下面三个方便的区别：修饰符，返回值，命名。和方法一样，构造器可拍此棚以有任何访问的修饰： public, protected, private或者没有修饰（通常被package 和 friendly呼叫）. 不同于方法的是，构造器不能有以下非访问性质的修饰： abstract, final, native, static, 或者 synchronized。
返回型别也是非常重要的。方法能返回任何型别的值或者无返回值（void），构造器没有返回值，也不需要void。
最后，谈谈两者的命名。构造器使用和类相同的名字，而方法则不同。按照习惯，方法通常用小写字母开始，而构造器通常用大写字母开始。构造器通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作。
"this"的用法
构造器和方法使用关键字this有很大的区别。方法引用this指向正在执行方法的类的例项。静态方法不能使用this关键字，因为静态方法不属于类的例项，所以this也就没有什么东西去指向。构造器的this指向同一个类中，不同引数列表的另外一个构造器，我们看看下面的程式码：
public class Platypus {
String name;
Platypus(String input) {
name = input;
}
Platypus() {
this("John/Mary Doe");
}
public static void main(String args[]) {
Platypus p1 = new Platypus("digger");
Platypus p2 = new Platypus();
}
}
在上面的程式码中，有2个不同引数列表的构造器。第一个构造器，给类的成员name赋值，第二个构造器，呼叫第一个构造器，给成员变数name一个初始值 "John/Mary Doe".
在构造器中，如果要使用关键字this,那么，必须放在第一行，如果不这样，将导致一个编译错误。
"super"的用法
构造器和方法，都用关键字super指向超类，但是用的方法不一样。方法用这个关键字去执行被过载的超类中的方法。看下面的例子：
class Mammal {
void getBirthInfo() {
System.out.println("born alive.");
}
}
class Platypus extends Mammal {
void getBirthInfo() {
System.out.println("hatch from eggs");
System.out.print("a mammal normally is ");
super.getBirthInfo();
}
}
在上面的例子中，使用super.getBirthInfo()去呼叫超类Mammal中被过载的方法。
构造器使用super去呼叫超类中的构造器。而且这行程式码必须放在第一行，否则编译将出错。看下面的例子：
public class SuperClassDemo {
SuperClassDemo() {}
}
class Child extends SuperClassDemo {
Child() {
super();
}
}
在上面这个没有什么实际意义的例子中，构造器 Child()包含了 super,它的作用就是将超类中的构造器SuperClassDemo例项化，并加到 Child类中。
编译器自动加入程式码
编译器自动加入程式码到构造器，对于这个，java程式设计师新手可能比较混淆。当我们写一个没有构造器的类，编译的时候，编译器会自动加上一个不带引数的构造器，例如：public class Example {}
编译后将如下程式码：
public class Example {
Example() {}
}
在构造器的第一行，没有使用super，那么编译器也会自动加上，例如：
public class TestConstructors {
TestConstructors() {}
}
编译器会加上程式码，如下：
public class TestConstructors {
TestConstructors() {
super;
}
}
仔细想一下，就知道下面的程式码
public class Example {}
经过会被编译器加程式码形如：
public class Example {
Example() {
super;
}
}
继承
构造器是不能被继承的。子类可以继承超类的任何方法。看看下面的程式码：
public class Example {
public void sayHi {
system.out.println("Hi");
}
Example() {}
}
public class SubClass extends Example {
}
类 SubClass 自动继承了父类中的sayHi方法，但是，父类中的构造器 Example()却不能被继承。
总结
主题
构造器
方法
功能
建立一个类的例项
java功能语句
修饰
不能用bstract, final, native, static,
or synchronized
能
返回型别
没有返回值，没有void
有返回值，或者void
命名
和类名相同；通常为名词，大写开头
通常代表一个动词的意思，小写开头
this
指向同一个类中另外一个构造器，在第一行
指向当前类的一个例项，不能用于静态方法
super
呼叫父类的构造器，在第一行
呼叫父类中一个过载的方法
继承
构造器不能被继承
方法可以被继承
编译器自动加入一个预设的构造器
自动加入（如果没有）
不支援
编译器自动加入一个预设的呼叫到超类的构造器
自动加入（如果没有）
不支援
构造方法，可以理解为在物件使用之前必须呼叫的方法，而该类当中的其他方法则没这个必要
所以在建立物件的时候，不但要分配记忆体，还要呼叫构造方法
细微的差别
构造方法必须没有返回值，其他方法必须有返回值
构造方法有预设构造方法，而其他方法没有
java 类当中方法有返回值，并且习惯方法名开头小写！
构造方法没有返回值，而其写法特殊是
public/private + 类名 +（）+{}。是固定的
例如
class A{
private int id;
private String name;
public A(){}
public A(int id,String name){
this.id = id;
this.name = name;
}
}
第一个 public A(){}是预设的构造方法，第二是过载Full的构造方法。

java中呼叫方法,构造方法,例项方法有什么区别

java中所谓的构造方法是指JAVA虚拟机器在LOAD这个类的时候，利用构造方法来建立这个类的一个例项所呼叫的方法，典型的就是构造方法的过载，比如：
public class student{
private int id;
private String name;
private int age;
以 *** 现出构造方法的过载
public void student() {}
public void student(int id ,String name) { this.id=id; this.name= name;}
public void student(int id ,String name,int age) {this.id=id; this.name=name; this.age=age;}
}
呼叫方法是指已经在类库中写好的方法我们直接去呼叫就可以了，如：System.out.println();
至于例项方法可以理解为类的中普通方法如：get(),set()之类的

JAVA中构造方法和普通方法有什么区别

构造方法，只在建立物件的时候呼叫，用于初始化物件中的属性。
物件建立后，构造方法就不能呼叫了。
普通的物件方法，只能在物件建立后，被物件呼叫，可以呼叫多次。

JAVA类中类方法和例项方法有什么区别

就是 类的方法 跟 物件的方法 区别； 类里面的静态方法，类是可以直接呼叫； 类 其他方法，需要例项化才能呼叫，也就是只有物件才能呼叫

java 中的类方法和例项方法有什么区别呀?????

你说的类方法是不是静态方法呀,例项方法是不是指宣告物件后使用这个物件的方法呢. 首先你这两个名词说法我是真没听说过. 如果指静态方法的话,是指不用宣告就可以使用的方法, 这些方法被定义在一个静态类中,使用的直接写 类名.方法(); 而你所说的例项方法应该是那些非静态的方法,也就是说必须先宣告包含这个方法的类的例项,然后通过这个例项来使用这些方法. 这就是它们两个的不同点. 希望我没有理解错.

例项方法和类方法有什么区别啊？？？

例项方法是建立例项才有的方法
类方法是直接可以使用类引用，不需要例项化就可以使用的方法，一般在专案中类方法都是设定为工具类使用的

呼叫类方法与例项方法有什么区别

类方法可以直接呼叫，例项方法必须new出一个物件后，用物件引用来呼叫