我承认我基础差，但以下好像不能编译吧class{
public static void main() 通过 没有(无main)
{}
}
首先,main没有给定String[] args
第二编译的时候会出现:
e:\java\a.java:1: <identifier> expected
class {
^
e:\java\a.java:4: '{' expected
}
^
2 errors
public static void main() 通过 没有(无main)
{}
}
首先,main没有给定String[] args
第二编译的时候会出现:
e:\java\a.java:1: <identifier> expected
class {
^
e:\java\a.java:4: '{' expected
}
^
2 errors
應該是class a
{
public static void main()
{
}
}
interface test
{
void put();
}
class test 不能通过，接口和类不能重名
{
public void put()
{ }
}2
interface test
{
void put();
}
class testabstract implements test 不能通过（实例化的put没有被声明为public）
{
void put()
{ }
}3
interface test
{
void put();
}
class testabstract implements test 通过
{
public void put()
{ }
}4
class test2
{
public void put()
{
System.out.println("d");
}
}public class testabstract
{
public static void main(String args[]) 不能通过（t没有被初始化）
{
test2 t;
t.put();
}
}5
interface test1
{
void put();
}
public class testabstract
{
public static void main(String args[])
{
test1 t = new test1(); 不能通过，接口不能被初始化
t.put();
}
}6
abstract class test1
{
abstract void put(String a);
public void put()
{
System.out.println("d");
}
}
public class testabstract
{
public static void main(String args[]) 不能通过，抽象类不能被初始化
{
test1 t = new test1();
t.put();
}
}
1一个文件里，有一个类和一个接口，这时，类可以不声明为public，但是他们不能重名!
2接口没有将其方法声明为public，子类照样要将该方法声明为public!
3.接口将其方法声明为public，子类也要将该方法声明为public!
4.没有实例化的类不能调用实例（对象的）方法，仅声明不创建也不行!
5.抽象类（就算其中有非abstract方法）和所有的接口不能被初始化（实例化）!
6.要用到抽象类的方法（抽象的和不抽象的），只能去继承它。
也帮你补充一点：
没有必要声明为public的就不要声明为public！只有需要publish的才声明为public。
2.如果文件里有几个类，那么一定需要一个类为public(这个类里面一定要有main,
main肯定要用public static void 声明)，且文件名和该类名相同。改为如果文件里有几个类，也不一定需要一个类为public，但是如果要运行的话，则一定要有。
且这个类名就是文件名，main在这个类下。
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.最后一条，最为重要，也是不少初学者弄不清的地方：
调用一个接口，或者该接口的方法，要从调用该接口的实现类的对象着手，有了上面的验证，大家应该明白，这个对象所在类必定不是抽象的，必定实现了该接口的所有方法，或者继承于没有把该接口实现完全的抽象类，二者必居其一！这条意味这我这次测试的结束，谢谢大家。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
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);
}
}
－－－－－－－－－－－－－－
你说：如果有多个类实现了一个接口，那么到底实现哪个类的方法是在运行时确定的，也就是说，在main函数里面创建了哪个实现类的对象，就用该类的方法。这不是 默认的逻辑 吗？
类在继承接口时，如果将方法重写，那么在使用该类实例的时候，当然要使用该类改写过的方法。这有什么不清晰的地方，值得作者强调呢？
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
嗯..........我说的 继承后使用多态 是指多个类继承自某个基类,然后使用派生类声明基类对象( 基类 o = new 派生类 )
基类包含一个方法.如果 派生类修改了基类方法,那 o.方法() 就会调用派生类的方法.
如果 派生类没有修改基类方法,那 o.方法() 就会使用基类的方法.我觉得作者说的不是这个阿,还有你的例子中提到的[将class作为入参],那也是个很清晰的思路阿
用谁就调谁,没错把?
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
以上言论证明这点不仅仅是接口的特点，也是有继承（实现也是一种继承）关系的类的属性
比如在同一个java文件中，有一个接口，一个它的实现类，那么谁命名为public，这个文件的名字就应该是谁的，这和两个类在一个java文件里没什么区别。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
就是说，可以两个都没有public但是要有的话，一个文件里只能有一个，不管这个文件里有没有接口，因为接口也是类！
{
void a();
void b();
}
public class testInterface implements intrfac
{
public void a(){}
public void b(){}
public void c(){}
}
说明，接口和继承相似的地方，即如果某个类实现了某个接口，可以是is-a 关系，也可以是like-a关系。