所有基础不扎实的都来看看。

[qlampskyface]

程序 编译时通过的情况(javac) 解释时通过(java)
class{} 没有(说没有标识符) 没有


class testabstract{} 通过 没有(无main)


class{
public static void main() 通过 没有(无main)
{}
}


class{
public static void main(String s[])
{
System.out.println("d"); 通过 通过
}
}

class testabstract
{
//此文件被命名为tstabstract
public static void main(String s[]) 通过 没有类定义
{
System.out.println("dd");
}
}


public class testabstract
{

public static void main(String s[]) 通过 通过
{
System.out.println("dd");
}
}


abstract class testabstract
{
void getData(){}; 通过 没有(无main)
}

class testabstract
{
abstract void getData(){}; 没有(因为类没有被声明为abstract)
}


abstract class testabstract
{
abstract void getData(); 通过
}


abstract class testabstract
{
abstract void getData(){}; 不能通过(不能有方法体)
}


abstract class testabstract
{
abstract void getData(); 通过
void getData(String a){};
}



interface testabstract
{
abstract void getData(){}; 没有通过(不能有方法体{})
}


interface testabstract
{
abstract void getData(); 通过
}


interface testabstract
{
abstract void putAnswer();
void putAnswer(String a){}; 不能通过(不能有方法体{})
}


interface testabstract
{
abstract void putAnswer(); 通过
void putAnswer(String a);
}


interface testabstract
{
abstract void putAnswer(){};不能通过(不能有方法体{})
void putAnswer(String a);
}


interface testabstract
{
void putAnswer();
void putAnswer(String a); 通过
}


interface testabstract
{
void putAnswer(){};
void putAnswer(String a); 不能通过
}


abstract interface testabstract
{
abstract void getData(); 通过
}



abstract interface testabstract
{
void getData(); 通过
}



abstract interface testabstract
{
void getData(){}; 不能通过(不能有方法体)
}
看来有以下几点：
1.如果这个文件里有一个类，那么这个类可以不声明为public，文件名也可以不为这个类名，但是只能编译通过，不能运行通过。要想运行通过，只能将文件名和类名同名(这时也可以没有public)。
2.如果文件里有几个类，那么一定需要一个类为public(这个类里面一定要有main,
main肯定要用public static void 声明)，且文件名和该类名相同。
3.main的入参一定要是String[]，参数的名字可以不是args，比如可以是s。
4.类中要是有抽象方法，那么该类必须声明为抽象。但是该类中可以有非抽象方法。
5.接口中要是有抽象方法，接口不必声明为抽象。
6.接口中只要是含有方法体({})的方法，即报错，意即接口中不能有含有方法体的方法，不管该接口是否为abstract，也不管接口内是否有abstract方法。
7.一个没有abstract和有abstract的接口在编译时是相同的规定的。即不能有方法体!
8.所以说，是接口必为抽象！

[xiaohaiz]

俺学习中。
也帮你补充一点：
没有必要声明为public的就不要声明为public！只有需要publish的才声明为public。

[xiaozuidazhi]

我再学学！

[qlampskyface]

更正一下：
2.如果文件里有几个类，那么一定需要一个类为public(这个类里面一定要有main,
main肯定要用public static void 声明)，且文件名和该类名相同。

改为

如果文件里有几个类，也不一定需要一个类为public，但是如果要运行的话，则一定要有。
且这个类名就是文件名，main在这个类下。

[IEQQ]

谢谢，学习。

[mondschein]

ding

[chrisjen]

我在最近几天才真正理解了对象的概念.还有很多不明的
谢

[松耦合紧内聚]

0_0

[xunyiren]

xie xie

[HurricanDavidLiu]

mark
鼓励楼主继续（有点不劳而获了）
呵呵

[zjlgigi]

非常感谢楼主的心血~~~~

[海盗2019]

@<->@

[xiaozuidazhi]

挺好的，遇到这样的问题就应该自己实践！

[qlampskyface]

今天又有了一点收获，请大家指正！
1.
interface test
{
public int put();
public void t();
}
class subtest implements test
{ 不能通过，class要么要被声明为abstract
public int put() 要么实现t方法
{
int i = 1;
System.out.println(i);
return i;
}
}
2.
interface test
{
public int put(); 不能通过，put()已经定义
public void put();
}

3.
interface test
{
public int put();
public void t();
}
class subtest implements test
{
public int put()
{
int i = 1;
System.out.println(i);
return i;
}
public void t()
{}
}
class ref
{
public ref(test t)
{
t.put();
}
}
public class testabstract
{
public static void main(String args[])
{
testabstract tst = new testabstract(); 通过
}
public testabstract()
{
subtest st = new subtest();
ref r = new ref(st);
}
}
1.说明一个类如果只实现了一个接口的一个方法（该接口有两个或两个以上的方法），只能被声明为抽象类，这时，使用该类的非抽象方法也得先继承，再使用。
2.如果不想声明该类为抽象类，则要实现其接口的所有方法!
3.接口中不能重载方法！当然，实现它的类也就不能重载这个方法（验证）！

4.最后一条，最为重要，也是不少初学者弄不清的地方：
调用一个接口，或者该接口的方法，要从调用该接口的实现类的对象着手，有了上面的验证，大家应该明白，这个对象所在类必定不是抽象的，必定实现了该接口的所有方法，或者继承于没有把该接口实现完全的抽象类，二者必居其一！

这条意味这我这次测试的结束，谢谢大家。

[xiaozuidazhi]

楼主的精神令人佩服！
学习！

[pudding205]

涨知识了，楼住，继续！
我帮你顶！

[qlampskyface]

再补充一点，如果有多个类实现了一个接口，那么到底实现哪个类的方法是在运行时确定的，也就是说，在main函数里面创建了哪个实现类的对象，就用该类的方法。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
interface test
{
public int put();
public void t();
}
class subtest1 implements test
{
public int put()
{
int i = 1;
System.out.println(i);
return i;
}
public void t()
{}
}
class subtest2 implements test
{
public int put() 编译，解释均通过
{
int i = 2;
System.out.println(i);
return i;
}
public void t()
{}
}
class ref
{
public ref(test t)
{
t.put();
}
}
public class testabstract
{
public static void main(String args[])
{
testabstract tst = new testabstract();
}
public testabstract()
{
subtest2 st = new subtest2();
ref r = new ref(st);
}
}

[qlampskyface]

所以说，关键是找出引用接口的对象的地方，即找出接口的对象被当作入参传入的地方，然后在main中创建实现该接口的类的对象，将该对象传入上述地方，然后，当main里面调用到“接口.方法”时，自然调用的是那个已经被创建的实现类的对象，进而调用该对象的方法。

[qlampskyface]

badcody(升龙就是硬道理)：
－－－－－－－－－－－－－－
你说：

如果有多个类实现了一个接口，那么到底实现哪个类的方法是在运行时确定的，也就是说，在main函数里面创建了哪个实现类的对象，就用该类的方法。

这不是 默认的逻辑 吗？
类在继承接口时，如果将方法重写，那么在使用该类实例的时候，当然要使用该类改写过的方法。

这有什么不清晰的地方，值得作者强调呢？
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
嗯..........我说的 继承后使用多态 是指

多个类继承自某个基类,然后使用派生类声明基类对象( 基类 o = new 派生类 )
基类包含一个方法.

如果 派生类修改了基类方法,那 o.方法() 就会调用派生类的方法.
如果 派生类没有修改基类方法,那 o.方法() 就会使用基类的方法.

我觉得作者说的不是这个阿,还有你的例子中提到的[将class作为入参],那也是个很清晰的思路阿
用谁就调谁,没错把?
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
以上言论证明这点不仅仅是接口的特点，也是有继承（实现也是一种继承）关系的类的属性

[xiaozuidazhi]

接口只不过是个特殊的类而已，虽然有的人觉得它在类之上。
比如在同一个java文件中，有一个接口，一个它的实现类，那么谁命名为public，这个文件的名字就应该是谁的，这和两个类在一个java文件里没什么区别。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
就是说，可以两个都没有public

但是要有的话，一个文件里只能有一个，不管这个文件里有没有接口，因为接口也是类！

[qlampskyface]

interface intrfac
{
void a();
void b();
}
public class testInterface implements intrfac
{
public void a(){}
public void b(){}
public void c(){}
}
说明，接口和继承相似的地方，即如果某个类实现了某个接口，可以是is-a 关系，也可以是like-a关系。