主类main方法里面可以有不带public的子类 但是不能有接口

简介:

1.//还可以写在main外面     
2. interface product{  
3.            public void getName();  
4.            }  
5.     class productA implements product {  
6.            @Override  
7.            public void getName() {  
8.                // TODO Auto-generated method stub  
9.                System.out.println("++++A++++");  
10.            }  
11.              
12.        }  
13.         class productB implements product{  
14.            @Override  
15.            public void getName() {  
16.                // TODO Auto-generated method stub  
17.            System.out.println("++++++B++++++");      
18.            }  
19.        }  
20.         class createProduct{  
21.            public product create(String type) {  
22.                if("A".equals(type))  
23.                    return new productA();  
24.                else if("B".equals(type))  
25.                    return new productB();  
26.                else  
27.                return null;  
28.            }  
29.        }  
30.public class factory {  
31.    public static void main(String args[]){  
32.      
33.        createProduct create = new createProduct();  
34.        create.create("A").getName();  
35.        create.create("B").getName();  
36.          
37.    }  
38.      
39.      
40.}   


主类main方法里面可以有不带public的子类  但是不能有接口

接口写在主类的外面  但是不能带public   interface product{

1.            public void getName();  
2.            }  
3.              
4.public class factory {  
5.    public static void main(String args[]){  
6.         class productA implements product {  
7.                @Override  
8.                public void getName() {  
9.                    // TODO Auto-generated method stub  
10.                    System.out.println("++++A++++");  
11.                }  
12.                  
13.            }  
14.             class productB implements product{  
15.                @Override  
16.                public void getName() {  
17.                    // TODO Auto-generated method stub  
18.                System.out.println("++++++B++++++");      
19.                }  
20.            }  
21.             class createProduct{  
22.                public product create(String type) {  
23.                    if("A".equals(type))  
24.                        return new productA();  
25.                    else if("B".equals(type))  
26.                        return new productB();  
27.                    else  
28.                    return null;  
29.                }  
30.            }  
31.        createProduct create = new createProduct();  
32.        create.create("A").getName();  
33.        create.create("B").getName();  
34.          
35.    }  
36.      
37.      
38.}  


相关文章
|
1月前
|
Java
java中父类方法return this.对象还是变量,子类去调用this.这个方法的问题
本文探讨了在Java中,当父类的方法返回`this`对象或变量时,子类调用该方法的行为,以及`this`关键字在不同类中调用方法时的指向问题。
14 0
java中父类方法return this.对象还是变量,子类去调用this.这个方法的问题
|
6月前
|
存储 Java 编译器
实例化&&构造方法&&static统统都学会
实例化&&构造方法&&static统统都学会
43 0
Java-----抽象类为什么不能实例化?抽象方法为什么不能被static修饰?set和get方法的使用方法
Java-----抽象类为什么不能实例化?抽象方法为什么不能被static修饰?set和get方法的使用方法
|
存储 C++
【C++类】 -- 类与static
【C++类】 -- 类与static
62 0
|
6月前
|
Java 编译器
【Java 方法重写】@Override 注解,一般用法,重写的具体要求
【Java 方法重写】@Override 注解,一般用法,重写的具体要求
363 0
java一个文件只能有一个公有类的解决方法。 用公有静态内部类。 public static。 类似于C++的命令空间。
java一个文件只能有一个公有类的解决方法。 用公有静态内部类。 public static。 类似于C++的命令空间。
Java——重写(Override)与重载(Overload)(概念理解+应用举例)
Java——重写(Override)与重载(Overload)(概念理解+应用举例)
Java——重写(Override)与重载(Overload)(概念理解+应用举例)
|
存储 Java 编译器
Java面向对象——封装、构造方法、private、static
Java面向对象——封装、构造方法、private、static
388 0
Java面向对象——封装、构造方法、private、static
|
编译器 C++ 开发者
关于前置声明:#include类和前置class类名的区别
关于前置声明:#include类和前置class类名的区别
241 0
关于前置声明:#include类和前置class类名的区别
|
存储 Java
当类中的方法全部都是 static 关键字修饰时 ,它的构造方法最好作为 private 私有化,理由是方法全是 static, 不知道的人会去new对象去调用,需要调用构造方法。 但 static的方法直接用类名调用就行!
当类中的方法全部都是 static 关键字修饰时 ,它的构造方法最好作为 private 私有化,理由是方法全是 static, 不知道的人会去new对象去调用,需要调用构造方法。 但 static的方法直接用类名调用就行! -----------------------------------------------------------------------------static关键字的特点   A:static关键字的特点     a:随着类的加载而加载     b:优先于对象存在     c:被类的所有对象共享       举例:咱们班级的学生应该共用同一个班级编号。
1291 0