面向对象_02

Posted 2020-10-16

单例模式概念：设计一个类时，保证在整个程序运行期间针对该类只存在一个实例对象。

设计模式：对问题行之有效的解决方式。【一种思想】
1, 单例设计模式
解决问题：就是可以保证一个类在内存中的对象唯一性。
比如：对于多个程序使用同一个配置信息对象时候，就需要保证该对象的唯一性。
如何保证对象的唯一性？
1，不允许其他程序用new创建该类对象
2，在该类创建一个本类实例
3，对外提供一个方法让他程序可以获取该对象。
步骤：
1，私有化该类构造函数
2，通过new在本类中创建一个本类对象
3，定义一个公有的方法，将创建的对象返回
实例代码：

 1 //单例设计模式
 2 package new_Object;
 3 class Single{
 4     //通过new在本类中创建一个本类对象
 5     private static Single INSTANCE=new Single();
 6     private  Single (){}//私有化构造方法
 7     public static Single getInstance(){ //提供返回该对象的静态方法
 8         return INSTANCE;
 9     }
10 }
11 public class Example_18 {
12     public static void main(String[] args) {
13         Single s1=Single.getInstance();
14         Single s2=Single.getInstance();
15         System.out.println(s1==s2);
16     }
17 }

单例模式测试：

 1 //单例模式测试s
 2 package new_Object;
 3 class Test{
 4         private int num;
 5         //通过new在本类中创建一个本类对象
 6         private static Test INSTANCE=new Test();
 7         private Test(){};//私有化该类构造函数
 8         public static Test getInstance(){    //提供返回该对象的静态方法
 9             return INSTANCE;
10         }
11         //获取值
12         public int getNum(){
13             return num;
14         }
15         public void setNum(int num){
16             this.num=num;
17         }
18     }
19 public class SingleTest{
20     public static void main(String[] args) {
21 //        Test t1=new Test();
22 //        Test t2=new Test();
23         Test t1=Test.getInstance();
24         Test t2=Test.getInstance();
25         t1.setNum(15);
26         t2.setNum(20);
27         System.out.println(t1.getNum());
28         System.out.println(t2.getNum());
29     }
30 }
31 /**单例三步走：
32    1，通过new在本类中创建一个本类对象
33           private static 本类名 变量名=new 本类名();
34    2，私有化该类构造函数
35        private 本类名(){};
36    3,提供返回该对象的静态方法
37         public static 本类名 方法名(){    
38             return 变量名;
39         }
40       主函数调用：
41     类名 变量名= 类名.方法名
42  * 
43  */

 

内部类：类的内部定义类，这个内部类所在的类称外部类。
分类：成员内部类、静态内部类、方法内部类
成员内部类中可以访问外部类的所有成员
内部类代码示例：

 1 package new_Object;
 2  class Outer_01{
 3          private int num=3;//定义成员变量
 4         //定义成员方法，方法中访问成员内部类
 5         public void test(){
 6             Inner inner=new Inner();
 7             inner.show();
 8         }
 9         //定义成员内部类
10 class Inner{
11         void show(){
12             //内部类访问外部变量
13             System.out.println("num="+num);
14         }
15     }
16 }
17 public class Inner_class {//内部类
18     public static void main(String[] args) {
19         Outer_01 outer=new Outer_01();//创建外部类对象
20         outer.test();//调用test方法
21     }
22 }

外部类访问内部类：通过外部类对象创建内部类对象
　　格式：外部类访问内部类，则外部类名.内部类名 变量名=new 外部类名().new 内部类名();
代码示例：

 1 package new_Object;
 2  class Outer_01{
 3          private int num=3;//定义成员变量
 4         //定义成员方法，方法中访问成员内部类
 5         public void test(){
 6             Inner inner=new Inner();
 7             inner.show();
 8         }
 9         //定义成员内部类
10 class Inner{
11         void show(){
12             //内部类访问外部变量
13             System.out.println("num="+num);
14         }
15     }
16 }
17 public class Inner_class {//内部类
18     public static void main(String[] args) {
19 
20     
21     //外部类访问内部类，则外部类名.内部类名 变量名=new 外部类名().new 内部类名();
22         Outer_01.Inner inner=new Outer_01().new Inner();
23         inner.show();
24     }
25 }

run：==>3
注：报错：内部类被私有，则外界不可访问内部 即class Inner改成private class Inner

静态内部类：使用static关键字来修饰一个成员内部类，可以不创建外部类名对象的情况下被实例化。
　　格式：外部类名.内部类名 变量名=new 外部类名.内部类名();
代码示例：

 1 //静态内部类
 2 package new_Object;
 3 class Outer_02{
 4         private static int num=4;
 5         //定义静态内部类 Inner
 6         static class Inner{
 7             void show(){
 8                 System.out.println("num="+num);
 9             }
10         }
11     }
12 public class Static_class {
13     public static void main(String[] args) {
14     //格式：外部类名.内部类名 变量名-new 外部类名.内部类名();
15         Outer_02.Inner inner=new Outer_02.Inner();//创建内部类对象
16         inner.show();//调用内部类方法
17     }
18 }

run：==>4
注:　　1，静态内部类中只能访问外部类的静态成员，private static int num=4;去掉static则报错
　　　 2，报错：静态内部可定义静态成员，非静态类中不可定义静态成员

1 class Outer{
2         class Inner{
3             static int num=3;
4             void show(){
5             System.out.println("num="+num);
6         }
7     }
8 }

 
方法内部类：成员方法中定义的类，只能在当前方法中被调用。方法内部类也可以访问外部类的成员变量

 1 //方法内部类
 2 package new_Object;
 3 class Outer_03{
 4     private int num=5;//定义成员变量
 5     //定义test方法
 6     public void test(){
 7         //方法中定义内部类
 8         class Inner{
 9             void show(){
10                 System.out.println("num="+num);//访问外部成员变量
11             }
12         }
13         Inner in=new Inner();//创建内部对象
14         in.show();//调用内部方法
15     }
16 }
17 public class Fun_class {
18     public static void main(String[] args) {
19         Outer_03 outer=new Outer_03();//创建外部对象
20         outer.test();//调用test方法
21     }
22 }

run==>5

Java帮助文档：Java语言支持的第三种注释方式==>以/**开头， */结尾.
java提供javadoc命令，将帮助信息提取出来，自动生成html格式的帮助文档，实现程序的文档化。
@author：用于类的说明，表示程序的作者
@version：用于类的说明，表示程序开发的版本号
@param：用于对方法的说明，表示方法定的参数以及参数对应的说明
@return：用于对方法的说明，表示方法的返回值代表的意义
DOS：javadoc -d . -version -author -Person.java
　　-d=>指定目录
　　.=> 当前目录
　　-version=>版本信息
　　-author=>作者信息
执行javadoc后会出现一系列的文件，其中index.html文件就是整个帮助文档的首页，双击打开即可看到帮助信息。
一般javadoc出现在当前目录下生成的文档会比较杂乱，通过可以创建文件夹即可，去掉点 . 改成文件夹名help：
格式：javadoc -d 文件夹名 -version -author -类名.java
　==>javadoc -d help -version -author -Person.java