java方法不同

‘壹’ java中普通方法、抽象方法、构造方法等都有什么不同和作用呢

举例说明吧，学生是一个大类（在程序中就是class），其中的一个学生是一个对象也叫一个实体（在程序中就是我们new的一个对象），接口实际上是一个类，实现接口的类相当于是一个调用关系，抽象类也是一个类，但和接口不同，实现抽象类的类是一个继承的关系，继承只能继承一个，好比只有一个父亲，但是接口可以接很多个，好比usb插口，普通方法就是我们平时写的void
int
string
等等的函数方法，如果是写在类里面，那么其他地方调用需要先实例化一个对象（new一个对象）然后再按.调用出来，静态方法就是前面加了static的方法，是使用公共内存空间的，所有对象都可以直接引用而不需要实例化一个对象再使用该方法。静态块的就是在类加载的时候就执行，而且是一个类在第一次被使用的时候会被加载执行（这东西不常用）。

‘贰’ java静态方法和非静态方法有什么不同

静态方法和实例方法的区别主要体现在两个方面：

在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。

静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。

下面几个例子展示了这一区别。

1、调用静态方法示例。

//-----------文件名hasStaticMethod.java，程序编号1-----------------public
class hasStaticMethod{//定义一个静态方法public static void
callMe(){System.out.println("This is a static method.");}}

下面这个程序使用两种形式来调用静态方法。
//-----------文件名invokeStaticMethod.java，2-----------------

public class invokeStaticMethod{
public static void main(String args[]){
hasStaticMethod.callMe(); //不创建对象，直接调用静态方法
hasStaticMethod oa = new hasStaticMethod(); //创建一个对象oa.callMe(); //利用对象来调用静态方法}}

程序3.36两次调用静态方法，都是允许的，程序的输出如下：
This is a static method.This is a static method.
允许不创建对象而调用静态方法，是Java为了减少程序员调用某些常用方法时的麻烦，而允许程序员按照传统的C语言中使用函数的方式来使用方法。典型的例子是前面某些程序中使用"Math.ramdon()"来获取随机数。
2、静态方法访问成员变量示例。
//-----------文件名accessMember.java，程序编号3.37-----------------class
accessMember{private static int sa; //定义一个静态成员变量private int ia;
//定义一个实例成员变量//下面定义一个静态方法static void statMethod(){int i = 0;
//正确，可以有自己的局部变量sa = 10; //正确，静态方法可以使用静态变量otherStat(); //正确，可以调用静态方法ia =
20; //错误，不能使用实例变量insMethod(); //错误，不能调用实例方法}static void otherStat(){}
//下面定义一个实例方法 void insMethod(){int i = 0; //正确，可以有自己的局部变量sa = 15;
//正确，可以使用静态变量ia = 30; //正确，可以使用实例变量statMethod(); //正确，可以调用静态方法}}

本例其实可以概括成一句话：静态方法只能访问静态成员，实例方法可以访问静态和实例成员。之所以不允许静态方法访问实例成员变量，是因为实例成员变量是属于某个对象的，而静态方法在执行时，并不一定存在对象。同样，因为实例方法可以访问实例成员变量，如果允许静态方法调用实例方法，将间接地允许它使用实例成员变量，所以它也不能调用实例方法。基于同样的道理，静态方法中也不能使用关键字this。

main()方法是一个典型的静态方法，它同样遵循一般静态方法的规则，所以它可以由系统在创建对象之前就调用。

‘叁’ java实现线程的两种方法有什么区别

为什么Java要提供两种方法来创建线程呢？它们都有哪些区别？相比而言，哪一种方法更好呢？

在Java中，类仅支持单继承，也就是说，当定义一个新的类的时候，它只能扩展一个外部类.这样，如果创建自定义线程类的时候是通过扩展 Thread类的方法来实现的，那么这个自定义类就不能再去扩展其他的类，也就无法实现更加复杂的功能。因此，如果自定义类必须扩展其他的类，那么就可以使用实现Runnable接口的方法来定义该类为线程类，这样就可以避免Java单继承所带来的局限性。

还有一点最重要的就是使用实现Runnable接口的方式创建的线程可以处理同一资源，从而实现资源的共享.

1、通过扩展Thread类来创建多线程

假设一个影院有三个售票口，分别用于向儿童、成人和老人售票。影院为每个窗口放有100张电影票，分别是儿童票、成人票和老人票。三个窗口需要同时卖票，而现在只有一个售票员，这个售票员就相当于一个CPU，三个窗口就相当于三个线程。通过程序来看一看是如何创建这三个线程的。

[html]view plain

结果正如前面分析的那样，程序在内存中仅创建了一个资源，而新建的三个线程都是基于访问这同一资源的，并且由于每个线程上所运行的是相同的代码，因此它们执行的功能也是相同的。

可见，如果现实问题中要求必须创建多个线程来执行同一任务，而且这多个线程之间还将共享同一个资源，那么就可以使用实现Runnable接口的方式来创建多线程程序。而这一功能通过扩展Thread类是无法实现的

‘肆’ java 两个线程执行不同的方法

首先你这说法似乎有点错误，不知道你是否把C#里面的线程用法用到java上面了。
首先，java里面的线程，只是执行一个方法，那个方法名为 public void run(){}
再次，在java里面，使用线程是要继承Thread类(重写run方法)，或者是实现Runnable接口（实现run方法）
然后，建立一个线程，是
1、继承线程Thread类： MyThread thread=new MyThread();
启动：thread.start();这样就启动一个线程，但它只是执行run方法里面的东西

2、实现Runnable接口的：MyRunnableThread thread=new MyRunnableThread()；
启动： Thread runThread=new Thread(thread); runThread.start();(或者直接写为：new Thread(thread).start() )

最后，在这里你应该可以看到了，这是一个类线程，不是一个方法线程。如果你要执行多个方法，就要多写和创建启动多个线程类

‘伍’ java课程培训机构分享Java构造器和方法的区别

构造函数（构造器）是一种特殊的函数。其主要功能是用来在创建对象时初始化对象，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。构造函数与类名相同，可重载多个不同的构造函数。在JAVA语言中，构造函数与C++语言中的构造函数相同,JAVA语言中普遍称之为构造方法。java课程培训机构http://www.kmbdqn.com/来为大家介绍一下。

构造方法的声明：

修饰符class_name(类名)(参数列表){

逻辑代码

}

构造器特性：

1.如果我们的类当中没有定义任何构造器，系统会给我们默认提供一个无参的构造器。

2.如果我们的类当中定义了构造器，那么系统就不会再给我们提供默认的无参构造器。

作用：构建创造一个对象。同时可以给我们的属性做一个初始化操作。

下面主要学习构造器和方法的区别：

我们说构造器是一种方法，就象讲澳大利亚的鸭嘴兽是一种哺育动物。（按：老外喜欢打比喻，我也就照着翻译）。要理解鸭嘴兽，那么先必须理解它和其他哺育动物的区别。同样地，要理解构造器，那么就要了解构造器和方法的区别。所有学习java的人，尤其是对那些要认证考试的，理解构造器是非常重要的。下面将简单介绍一下，最后用一个表作了些简单的总结。

1、功能和作用的不同

构造器是为了创建一个类的实例。用来创建一个对象，同时可以给属性做初始化。这个过程也可以在创建一个对象的时候用到：Platypusp1=newPlatypus();

相反，方法的作用是仅仅是功能函数，为了执行java代码。

2、修饰符，返回值和命名的不同

构造器和方法在下面三个方便的区别：修饰符，返回值，命名。

和方法一样，构造器可以有任何访问的修饰：public,protected,private或者没有修饰（通常被package和friendly调用）.不同于方法的是，构造器不能有以下非访问性质的修饰：abstract,final,native,static,或者synchronized。

3、返回类型

方法必须要有返回值，能返回任何类型的值或者无返回值（void），构造器没有返回值，也不需要void。

4、命名

构造器使用和类相同的名字，而方法则不同。按照习惯，方法通常用小写字母开始，而构造器通常用大写字母开始。

构造器通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作。

5、调用：

构造方法：只有在对象创建的时候才会去调用，而且只会调用一次。

一般方法：在对象创建之后才可以调用，并且可以调用多次。

‘陆’ Java的方法区和本地方法区有何不同什么是Native Method

java的方法区在jdk7及以前是永久代，使用的是虚拟机的内存，而到了jdk8，元空间取代了永久代，使用的是本地的内存。
Native Method是本地方法的意思，非java编写，比如c/c++，一般用于操作底层的硬件。在java中通过本地方法接口也就是带native修饰符的方法来调用本地方法。

‘柒’ Java语言中，构造方法和一般方法有何不同

构造方法和方法的区别：
构造方法要与类名相同，无返回类型，在类初始化的时候调用。
方法最好与类名不同，对象调用，静态方法可用类名.方法（）.

构造器和方法在下面三个方面区别：修饰符，返回值，命名。

1。和方法一样，构造器可以有任何访问的修饰： public, protected, private或者没有修饰（通常被package 和 friendly调用）. 不同于方法的是，构造器不能有以下非访问性质的修饰： abstract, final, native, static, 或者 synchronized。
2。返回类型也是非常重要的。方法能返回任何类型的值或者无返回值（void），构造器没有返回值，也不需要void。
3。两者的命名。构造器使用和类相同的名字，而方法则不同。按照习惯，方法通常用小写字母开始，而构造器通常用大写字母开始。构造器通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作。

构造方法和方法中this和supper的用法区别：

"this"的用法
构造器和方法使用关键字this有很大的区别。方法引用this指向正在执行方法的类的实例。静态方法不能使用this关键字，因为静态方法不属于类的实 例，所以this也就没有什么东西去指向。构造器的this指向同一个类中，不同参数列表的另外一个构造器，我们看看下面的代码：

package com.dr.gouzao;

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();
System.out.println(p1.name + "----" + p2.name);
}
}
在上面的代码中，有2个不同参数列表的构造器。第一个构造器，给类的成员name赋值，第二个构造器，调用第一个构造器，给成员变量name一个初始值 "John/Mary Doe".

在构造器中，如果要使用关键字this,那么，必须放在第一行，如果不这样，将导致一个编译错误。
在一个构造方法中只能调用一次其它的构造方法，并且调用构造方法的语句必须是第一条语句。

"super"的用法

构造器和方法，都用关键字super指向超类，但是用的方法不一样。方法用这个关键字去执行被重载的超类中的方法。看下面的例子：

package com.dr.gouzao;

class Mammal {
void getBirthInfo() {
System.out.println("born alive.");
}
}

class Platypus1 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类中。

编译器自动加入代码 ，当我们写一个没有构造器的类，编译的时候，编译器会自动加上一个不带参数的构造器。

现在具体介绍一下构造方法的几种用法：
类的继承机制使得子类可以使用父类的功能（即代码），并且子类也具有父类的类型。下面介绍类在继承关系上的初始化的顺序问题。
示例1：

class SuperClass
{
SuperClass()
{
System.out.println("SuperClass constructor");
}
}
public class SubClass extends SuperClass
{
SubClass()
{
System.out.println("SubClass constructor");
}
public static void main(String[] args)
{
SubClass sub = new SubClass();
}
}

输出结果： SuperClass constructor
SubClass constructor
在子类中只实例化了一个子类对象。从输出结果上看，程序并不是一开始就运行自己的构造方法，而是先运行其父类的默认构造方法。注意：程序自动调用其父类的默认构造方法。
实例2

class SuperClass
{
SuperClass(String str)
{
System.out.println("Super with a string.");
}
}
public class SubClass extends SuperClass
{
SubClass(String str)
{
System.out.println("Sub with a string.");
}
public static void main(String[] args)
{
SubClass sub = new SubClass("sub");
}
}

在JDK下编译此程序不能成功。正如上例中说的：程序在初始化子类时先要寻找其父类的默认构造方法，结果没找到，那么编译自然不能通过。

解决这个问题有两个办法：

1．在父类中增加一个默认构造方法。
2．在子类的构造方法中增加一条语句：super(str); 且必须在第一句。

这两种方法都能使此程序通过编译，但就本程序来说运行结果却不相同。

第1种方法的运行结果是：

Sub with a string.

第2种方法的运行结果是：

Super with a string.
Sub with a string.

第2种解决方法实际上是指定编译器不要寻找父类的默认构造方法，而是去寻找带一个字符串为参数的构造方法。

下面介绍对象的初始化顺序问题。

示例3：

class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two = new Two("two");
}
}

输出结果：
Test main() start...
one-1
one-2
one-3
two
在main()方法中实例化了一个Two类的对象。但程序在初始化Two类的对象时，并非先调用Two类的构造方法，而是先初始化Two类的成员变量。这里Two类有3个成员变量，它们都是One类的对象，所以要先调用3次One类的相应的构造方法。最后在初始化Two类的对象。
即在创建对象时，对象所在类的所有数据成员会首先进行初始化，如果其中的成员变量有对象，那么它们也会按照顺序执行初始化工作。在所有类成员初始化完成后，才调用对象所在类的构造方法创建对象。构造方法作用就是初始化。

示例4：

class One

{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two_1 = new Two("two-1");
System.out.println("------------");
Two two_2 = new Two("two-2");
}
}

输出结果：
Test main() start...
one-3
one-1
one-2
two-1
------------
one-1
one-2
two-2
如果一个类中有静态对象，那么它会在非静态对象前初始化，但只初始化一次。非静态对象每次调用时都要初始化。
实例5

class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
3
}
public class Test
{
static Two two_3 = new Two("two-3");
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two_1 = new Two("two-1");
System.out.println("------------");
Two two_2 = new Two("two-2");
}
}

输出结果：
one-3
one-1
one-2
two-3
Test main() start...
one-1
one-2
two-1
------------
one-1
one-2
two-2
程序中主类的静态变量会在main()方法执行前初始化。结果中只输出了一次one-3，这也说明：如果一个类中有静态对象，那么它会在非静态对象前初始化，但只初始化一次。非静态对象每次调用时都要初始化。

实例6

class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
static int i = 0;
One one_1 = new One("one-1");
static One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
System.out.println("Two.i = " Two.i);
}
}

输出结果：
Test main() start...
one-2
one-3
Two.i = 0
不仅第1次创建对象时，类中所有的静态变量要初始化，第1次访问类中的静态变量（没有创建对象）时，该类中所有的静态变量也要按照它们在类中排列的顺序初始化。

初始化的顺序包括构造方法调用的顺序如下：

1．主类的静态成员首先初始化。
2．主类的超类的构造方法按照从最高到最低的顺序被调用。
3．主类的非静态对象（变量）初始化。
4．调用主类的构造方法。

够详细了，记得结贴。

‘捌’ Java里不同方法里的局部变量的名称可以相同么！

java里不同方法里的局部变量的名称是可以相同的，因为不在一个作用域里面，如下代码：

packagecom.qiu.lin.he;


publicclassCeShi{
	publicstaticvoidmain(String[]args){
		CeShice=newCeShi();
		ce.ceshi();//调用第一个方法，输出他的局部变量i
		ce.ceshi2();//调用第二个方法，输出他的局部变量i

	}

	publicvoidceshi(){
		inti=1;
		System.out.println("我的局部变量是i");
	}

	publicvoidceshi2(){
		inti=1;
		System.out.println("我的局部变量也是i");
	}
}

输出结果为：

‘玖’ java 同名的不同方法共存的情况称为什么如何区分这些同名方法。

一般来说，分为两种情况。
一是在同一个类里面有两个或两个以上的同名的方法，这些方法的名字相同，但参数不同，这种情况中叫重载。当你调用方法时，会根据你传进去的参数的类型来决定调用哪个方法。
二是一个类继承了另外一个类，子类中有和父类中一样的方法，这两个方法不仅名字相同，参数也相同，这种情况叫方法覆盖。也就是在子类中重新定义父类中已有的方法。当你创建一个子类的实例后调用这个方法，就会按照你在子类中新定义的方法来实现。