实例_实例化 - CSDN
  • 对象和实例的区别

    2018-05-15 18:09:45
    有一种对象只叫对象,有...//Type是抽象类,不允许实例化,这里的type是Type类的对象,而非实例化对象(实例) 而普通类的对象,既可以叫对象,也可以叫实例化对象(实例),如下:class Person{} class Program ...

    有一种对象只叫对象,有一种对象叫实例化对象(实例)。

    我们知道抽象类是不可以被实例化的,那它的对象就不能叫实例化对象,只能叫对象,如下:

    Type type = typeof(int);//Type是抽象类,不允许实例化,这里的type是Type类的对象,而非实例化对象(实例)

     

    而普通类的对象,既可以叫对象,也可以叫实例化对象(实例),如下:


    class Person{}
    
    class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person();//这里person既可以叫做Person类的对象,也可以叫实例化对象(实例)
    } }

     

    展开全文
  • 数据结构实践教程:内含17个经典数据结构实例 根据五个不同数据结构,对每个结构都有2~4个经典实例。每个实例都有项目简介、设计思路、数据结构、完整程序、运行结果五个部分,可以直接拿来做一篇课程设计。实例名称...
  • 非常漂亮的100个前端案例,包含幻灯片切换、图片缩放、相册、放大镜、图片拖着滚动等等,只有你想不到。
  • 安装数据库,实例名为IPguard+名字缩写(例如:张三的实例名IPguardZhangs,如数据库已经安装了并运行正常请继续做下面的题)。 使用带加密的版本安装IP-guard服务器,注册、设置检验码(不要设置简单的检验码,如...
    1. 安装数据库,实例名为IPguard+名字缩写(例如:张三的实例名IPguardZhangs,如数据库已经安装了并运行正常请继续做下面的题)。
    2. 使用带加密的版本安装IP-guard服务器,注册、设置检验码(不要设置简单的检验码,如123,123456)。
    3. 打包客户端安装包安装客户端(可安装在IP-guard服务器上),在控制台能够看到客户端成功连上服务器。
    4. 打包用于域脚本安装的客户端安装包(域管理员账号密码:development.tec\abc 123),并将打包好的客户端安装包和域脚本工具放到同一目录。
    5. 使用远程安装工具安装客户端。
    6. 安装中继器并授权中继器的使用,设置该中继器管理范围为192.168.0.1-192.168.0.254,并限制中继器在工作时间(8:00-17:30)往主服务器传输的流量为200kb/s。
    7. 安装备用服务器并正确设置,备用服务器能正常连上服务器。
    8. 安装备份服务器并正确设置,备份服务器能正常连上服务器,并启用加密文档自动备份任务备份excle加密的文件,在客户端进行相应操作,能看到文档成功备份到服务器。
    9. 数据维护:设置数据清除,保留备份文档副本30天,超过时间自动清除,其它数据一直保留。
    10. 手动备份服务器上的所有数据(包括主数据库和日志数据库)到桌面目录。
    11. 安装web审批服务器,管理员A能通过浏览器登录审批系统。
    12. 安装安全审批APP并登陆app,对提交的解密申请查看申请的文件内容并进行审批。
    13. 安装安全文档查看器并授权查看器使用,设置每隔30天进行一次认证。
    14. 使用安全查看器查阅一份加密的word文档。
    15. 对客户端设置升级命令,并限制只在非工作时间(工作8:00-12;00,13:30-18:00)进行升级。
    16. 设置全盘扫描加密任务,对D盘的office文件(包括压缩包里面的office文件)进行扫描加密,扫描时间限制在非工作时间(工作8:00-12;00,13:30-18:00)。
    17. 迁移服务器和日志数据,停止旧服务器后客户端连接新服务器并可以查看以前的日志数据。
    18. 数据库与服务器分开部署(安装在不同虚拟机上),安装完成后正常可连接数据库实例
    展开全文
  • IP-GUARD简易安装手册

    2020-03-10 10:25:10
    IP-Guard简易安装手册 安装SQL server ,首先安装数据库所需要的组件,若已安装,请忽略此步骤。 打开安装文件,安装SQL server 2008 数据库; ...单击下一步后,会弹出选择SQL server数据库的框,确认SQL server...

    IP-Guard简易安装手册

    1. 安装SQL server ,首先安装数据库所需要的组件,若已安装,请忽略此步骤。

    打开安装文件,安装SQL server 2008 数据库;

    2、安装IPguard服务器和控制台。

    最好右键,选择以管理员身份运行。

    单击下一步后,会弹出选择SQL server数据库的框,确认SQL server数据库是创建数据库时的命名实例即可。

    然后单击下一步。

    升级成功后,填写产品注册信息,电子邮件地址记住,服务器可上外网的情况下,单击在线注册即可。否则联系销售提供给厂家商务注册。

     

    注册成功后,登录控制台。

    填写IPguard服务器IP地址,用户名admin,密码初始默认为空。

    IPGuard Client 生成(不要勾选静默安装

    展开全文
  • 多线程经典实例(一)

    2018-07-20 21:10:44
    在多线程的学习当中,有许多经典的例子值得学习,比如售票窗口、线程交替执行、生产者消费者等。下面就来看两个有关线程交替执行的案例。 两个线程轮流打印数字 这里采用 wait/notify 等待通知和 Lock/Condition ...

    在多线程的学习当中,有许多经典的例子值得学习,比如售票窗口、线程交替执行、生产者消费者等。下面就来看两个有关线程交替执行的案例。

    两个线程轮流打印数字

    这里采用 wait/notify 等待通知和 Lock/Condition 两种方式实现。

    wait()/notify()实现

    简单介绍一下wait/notify机制的几个方法。
    以下4个方法都必须在获取了锁的情况下才能调用:

    wait(): 使当前线程进入阻塞等待状态,直到被唤醒或中断; 调用后立即释放已有的锁;
    wait(Long times): 使当前线程进入阻塞等待状态一段时间,超过时间后自动唤醒;
    notify(): 唤醒在该对象上等待的一个线程;
    notifyAll(): 唤醒在该对象上等待的所有线程。

    释放锁的场景主要有3种:
    1. 执行完同步方法/代码块
    2. 执行同步方法/代码块的过程中遇到异常
    3. 执行同步方法/代码块的过程中调用了锁对象的wait()方法

    public class TurnsPrintNumber {
    
        private static Object lock = new Object(); //锁
        private static int i = 1;
    
        static class Print implements Runnable{
            @Override
            public void run() {
                while (true) {
                    synchronized (lock) {
                        if ( i > 20) {
                            System.out.println("打印完毕!");
                            lock.notify();
                            return;
                        }
                        System.out.println("线程" + Thread.currentThread().getName() + "打印:"  + i ++ );
                        lock.notify();
                        try {
                            Thread.sleep(100);
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    
        public static void main(String[] args) {
            Print print = new Print();
            new Thread(print).start();
            new Thread(print).start();
        }
    }
    Lock/Condition实现

    对于同一个锁(Lock对象)可以创建多个Condition,以便在不同的情况下使用不同的Condition。意思就是Condition可以明确指定唤醒哪一个线程。

    public class TurnsPrintNumber2 {
    
        private static ReentrantLock lock = new ReentrantLock();
        private Condition a = lock.newCondition();
        private Condition b = lock.newCondition();
        static int i = 1;
    
        private void print () {
            new Thread(() ->{
                while (i < 20) {
                    lock.lock();
                    System.out.println("线程1打印: " + i++);
                    try {
                        a.await(); //将线程1从运行状态->阻塞等待
                        b.signal();//唤醒线程2
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }).start();
    
            new Thread(() ->{
                while (i < 20) {
                    lock.lock();
                    System.out.println("线程2打印: " + i++);
                    try {
                        a.signal();
                        b.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }).start();
        }
    
        public static void main(String[] args) {
            new TurnsPrintNumber2().print();
        }
    }

    三个线程轮流打印 ABC

    线程1 打印 A,线程2 打印 B,线程3 打印 C, 线程1 打印 A………..

    采用以下3种方式实现:
    1. wait()/notify()方式
    2. Lock/Condition方式
    3. Semaphore信号量方式

    思路:

    要在3个线程间实现轮流打印的操作,最重要的就是要控制3个线程的执行顺序。也就是要确定等待、唤醒的顺序,所以每一个线程必须同时持有两个对象锁,才能继续执行。

    wait()/notify()实现
    public class TurnsPrintABCWaitNotify {
        private static Object alock = new Object();
        private static Object block = new Object();
        private static Object clock = new Object();
    
        public static void main(String[] args) {
    
            new Thread(() ->{
                for (int i = 0; i < 5; i++) {
                synchronized (alock) {  //先获取 A 的锁
                    synchronized (block) { //再获取 B 的锁
                        System.out.println("线程1打印:A");
                        block.notify();    //唤醒 B
                    }
                    if (i == 5){return;}//打印5次后结束
                        try {
                            alock.wait();  //释放 A 的锁,进入等待阻塞
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
    
            new Thread(() ->{
                for (int i = 0; i < 5; i++) {
                    synchronized (block) {
                        synchronized (clock) {
                            System.out.println("线程2打印:B");
                            clock.notifyAll();
                        }
                        try {
                            block.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
    
            new Thread(() ->{
                for (int i = 0; i < 5; i++) {
                    synchronized (clock) {
                        synchronized (alock) {
                            System.out.println("线程3打印:C");
                            alock.notifyAll();
                        }
                        try {
                            clock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
    
        }
    }
    Lock/Condition实现
    public class TurnsPrintABCLock {
    
        private static ReentrantLock lock = new ReentrantLock();
        private Condition a = lock.newCondition();
        private Condition b = lock.newCondition();
        private Condition c = lock.newCondition();
        int i = 1;
    
        private void print () {
            new Thread(() ->{
                while (i < 10) {
                    lock.lock();
                    System.out.println("线程1打印: " + "A");
                    i++;
                    if (i >= 10) {
                        System.out.println("打印完毕!");
                        return;
                    }
                    try {
                        b.signal(); //唤醒线程2
                        a.await(); //将线程1从运行状态->阻塞等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }).start();
    
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            new Thread(() ->{
                while (i < 10) {
                    lock.lock();
                    System.out.println("线程2打印: " +  "B");
                    i++;
                    if (i >= 10) {
                        System.out.println("打印完毕!");
                        return;
                    }
                    try {
                        c.signal();
                        b.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }).start();
    
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            new Thread(() ->{
                while (i < 10) {
                    lock.lock();
                    System.out.println("线程3打印: " +  "C");
                    i++;
                    if (i >= 10) {
                        System.out.println("打印完毕!");
                        return;
                    }
                    try {
                        a.signal();
                        c.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }).start();
        }
    
        public static void main(String[] args) {
            new TurnsPrintABCLock().print();
        }
    }
    Semaphore信号量实现
    public class TurnsPrintABCSemaphore {
        // A初始信号量数量为1
        private static Semaphore A = new Semaphore(1);
        // B、C初始信号数量为0
        private static Semaphore B = new Semaphore(0);
        private static Semaphore C = new Semaphore(0);
    
        static class ThreadA extends Thread {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        A.acquire();// A获取信号执行,A信号量减1,当A为0时将无法继续获得该信号量
                        System.out.println("线程1打印: " + "A");
                        B.release();
                        //System.out.println(B.drainPermits());//B释放之后信号量加1(初始为0),可以查看到 B 的信号量为1
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        static class ThreadB extends Thread {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        B.acquire();
                        System.out.println("线程2打印: " + "B");
                        C.release();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        static class ThreadC extends Thread {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        C.acquire();
                        System.out.println("线程3打印: " + "C");
                        A.release();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            new ThreadA().start();
            new ThreadB().start();
            new ThreadC().start();
        }
    }

    以上就是有关多个线程交替执行的例子。

    扩展

    如何保证线程的顺序执行?比如有a,b,c三个线程,如何保证a执行完再执行b,b执行完再执行c?
    1. Join
    2. 线程池(newSingleThreadExecutor)
    3. CountDownLatch/Semaphore

    展开全文
  • 转载来源:... package test1; /** * Title: Hello Java World * Description: 简单的Java程序,只显示一个信息。 * filename: HelloWorld.java */ pu...

    转载来源:https://blog.csdn.net/fljxzxb/article/details/6889084

    1. package test1;
    2. /**
    3. * Title: Hello Java World
    4. * Description: 简单的Java程序,只显示一个信息。
    5. * filename: HelloWorld.java
    6. */
    7. public class HelloWorld {
    8. public static void main(String[] args) {
    9. System.out.println("Hello Java World!");
    10. }
    11. }

    1. package test2;
    2. /**
    3. * Title: Java语言流程演示
    4. * Description: 演示Java中几种常用的流程控制操作
    5. * Filename: flowDome.java
    6. */
    7. public class flowDemo{
    8. public static void main(String[] arges){
    9. int iPara1,iPara2,iEnd;
    10. if(arges.length!=3)
    11. {
    12. System.out.println("USE :java flowDome parameter1 parameter2 circle");
    13. System.out.println("parameter1 : 比较条件1,数字类型");
    14. System.out.println("parameter2 : 比较条件2,数字类型");
    15. System.out.println("circle :循环次数");
    16. System.out.println("ego:java flowDome 1 2 5");
    17. return;
    18. }else{
    19. iPara1 = Integer.parseInt(arges[0]);
    20. iPara2 = Integer.parseInt(arges[1]);
    21. iEnd = Integer.parseInt(arges[2]);
    22. }
    23. //if语句
    24. if(iPara2>iPara1)
    25. {
    26. System.out.println("if 条件满足!");
    27. System.out.println("第2个数比第1个数大!");
    28. }
    29. else
    30. {
    31. System.out.println("if 条件不满足!");
    32. System.out.println("第2个数比第1个数小!");
    33. }
    34. //for循环操作
    35. for(int i=0;i<iEnd;i++)
    36. {
    37. System.out.println("这是for 第"+i+"次循环");
    38. }
    39. //while循环操作
    40. int i=0;
    41. while(i<iEnd)
    42. {
    43. System.out.println("这是while 第"+i+"次循环");
    44. i++;
    45. }
    46. //do-while循环操作
    47. int j=0;
    48. do
    49. {
    50. System.out.println("这是do-while 第"+j+"次循环");
    51. j++;
    52. }while(j<iEnd);
    53. }
    54. }

    1. package test3;
    2. /**
    3. * Title: 数组数据操作
    4. * Description: 演示一维数组和多维数组的初始化和基本操作
    5. * Filename: myArray.java
    6. */
    7. public class myArray{
    8. //初始化数组变量
    9. char[] cNum = {'1','2','3','4','5','6','7','8','9','0'};
    10. char[] cStr = {'a','b','c','d','e','f','g','h',
    11. 'i','j','k','l','m','n','o','p',
    12. 'q','r','s','t','u','v','w','x','y','z'};
    13. int[] iMonth = {31,28,31,30,31,30,31,31,30,31,30,31};
    14. String[] sMail = {"@","."};
    15. /**
    16. *<br>方法说明:校验电子邮件
    17. *<br>输入参数:String sPara 被校验的电子邮件字符
    18. *<br>返回类型:boolean 如果校验的格式符合电子邮件格式返回true;否则返回false
    19. */
    20. public boolean isMail(String sPara){
    21. for(int i=0;i<sMail.length;i++){
    22. if(sPara.indexOf(sMail[i])==-1)
    23. return false;
    24. }
    25. return true;
    26. }
    27. /**
    28. *<br>方法说明:判断是否是数字
    29. *<br>输入参数:String sPara。 需要判断的字符串
    30. *<br>返回类型:boolean。如果都是数字类型,返回true;否则返回false
    31. */
    32. public boolean isNumber(String sPara){
    33. int iPLength = sPara.length();
    34. for(int i=0;i<iPLength;i++){
    35. char cTemp = sPara.charAt(i);
    36. boolean bTemp = false;
    37. for(int j=0;j<cNum.length;j++){
    38. if(cTemp==cNum[j]){
    39. bTemp = true;
    40. break;
    41. }
    42. }
    43. if(!bTemp) return false;
    44. }
    45. return true;
    46. }
    47. /**
    48. *<br>方法说明:判断是否都是英文字符
    49. *<br>输入参数:String sPara。要检查的字符
    50. *<br>返回类型:boolean。如果都是字符返回true;反之为false
    51. */
    52. public boolean isString(String sPara){
    53. int iPLength = sPara.length();
    54. for(int i=0;i<iPLength;i++){
    55. char cTemp = sPara.charAt(i);
    56. boolean bTemp = false;
    57. for(int j=0;j<cStr.length;j++){
    58. if(cTemp==cStr[j]){
    59. bTemp = true;
    60. break;
    61. }
    62. }
    63. if(!bTemp) return false;
    64. }
    65. return true;
    66. }
    67. /**
    68. *<br>方法说明:判断是否是闰年
    69. *<br>输入参数:int iPara。要判断的年份
    70. *<br>返回类型:boolean。如果是闰年返回true,否则返回false
    71. */
    72. public boolean chickDay(int iPara){
    73. return iPara%100==0&&iPara%4==0;
    74. }
    75. /**
    76. *<br>方法说明:检查日期格式是否正确
    77. *<br>输入参数:String sPara。要检查的日期字符
    78. *<br>返回类型:int。0 日期格式正确,-1 月或这日不合要求, -2 年月日格式不正确
    79. */
    80. public int chickData(String sPara){
    81. @SuppressWarnings("unused")
    82. boolean bTemp = false;
    83. //所输入日期长度不正确
    84. if(sPara.length()!=10) return -2;
    85. //获取年
    86. String sYear = sPara.substring(0,4);
    87. //判断年是否为数字
    88. if(!isNumber(sYear)) return -2;
    89. //获取月份
    90. String sMonth = sPara.substring(5,7);
    91. //判断月份是否为数字
    92. if(!isNumber(sMonth)) return -2;
    93. //获取日
    94. String sDay = sPara.substring(8,10);
    95. //判断日是否为数字
    96. if(!isNumber(sDay)) return -2;
    97. //将年、月、日转换为数字
    98. int iYear = Integer.parseInt(sYear);
    99. int iMon = Integer.parseInt(sMonth);
    100. int iDay = Integer.parseInt(sDay);
    101. if(iMon>12) return -1;
    102. //闰年二月处理
    103. if(iMon==2&&chickDay(iYear)){
    104. if(iDay>29) return 2;
    105. }else{
    106. if(iDay>iMonth[iMon-1]) return -1;
    107. }
    108. return 0;
    109. }
    110. /**
    111. *<br>方法说明:主方法,测试用
    112. *<br>输入参数:
    113. *<br>返回类型:
    114. */
    115. public static void main(String[] arges){
    116. myArray mA = new myArray();
    117. //校验邮件地址
    118. boolean bMail = mA.isMail("tom@163.com");
    119. System.out.println("1 bMail is "+bMail);
    120. bMail = mA.isMail("tom@163com");
    121. System.out.println("2 bMail is "+bMail);
    122. //演示是否是数字
    123. boolean bIsNum = mA.isNumber("1234");
    124. System.out.println("1:bIsNum="+bIsNum);
    125. bIsNum = mA.isNumber("123r4");
    126. System.out.println("2:bIsNum="+bIsNum);
    127. //演示是否是英文字符
    128. boolean bIsStr = mA.isString("wer");
    129. System.out.println("1:bIsStr="+bIsStr);
    130. bIsStr = mA.isString("wer3");
    131. System.out.println("2:bIsStr="+bIsStr);
    132. //演示检查日期
    133. int iIsTime = mA.chickData("2003-12-98");
    134. System.out.println("1:iIsTime="+iIsTime);
    135. iIsTime = mA.chickData("2003-111-08");
    136. System.out.println("2:iIsTime="+iIsTime);
    137. iIsTime = mA.chickData("2003-10-08");
    138. System.out.println("3:iIsTime="+iIsTime);
    139. iIsTime = mA.chickData("2000-02-30");
    140. System.out.println("4:iIsTime="+iIsTime);
    141. }
    142. }

    1. package test4;
    2. import java.util.*;
    3. /**
    4. * Title: 矢量操作<
    5. * Description: 演示一个矢量(Vector)的基本操作
    6. * Filename: operateVector.java
    7. */
    8. public class operateVector
    9. {
    10. /*
    11. *<br>方法说明:生成一个4*4的二维Vector,供使用。
    12. *<br>输入参数:
    13. *<br>输出变量:Vector
    14. *<br>其它说明:
    15. */
    16. public Vector<Object> buildVector(){
    17. Vector<Object> vTemps = new Vector<Object>();
    18. for(int i=0;i<4;i++){
    19. Vector<Object> vTemp = new Vector<Object>();
    20. for (int j=0;j<4;j++){
    21. vTemp.addElement("Vector("+i+")("+j+")");
    22. }
    23. vTemps.addElement(vTemp);
    24. }
    25. return vTemps;
    26. }
    27. /*
    28. *<br>方法说明:插入数据
    29. *<br>输入参数:Vector vTemp 待插入的数据对象
    30. *<br>输入参数:int iTemp 插入数据的位置
    31. *<br>输入参数:Object oTemp 插入数据值
    32. *<br>输出变量:Vector 结果
    33. *<br>其它说明:如果插入位置超出实例实际的位置将返回null
    34. */
    35. public Vector<Object> insert(Vector<Object> vTemp,int iTemp,Object oTemp){
    36. if(iTemp>vTemp.size()){
    37. print("数据超界!");
    38. return null;
    39. }else{
    40. vTemp.insertElementAt(oTemp,iTemp);
    41. }
    42. return vTemp;
    43. }
    44. /*
    45. *<br>方法说明:移除数据
    46. *<br>输入参数:Vector vTemp 待删除矢量对象
    47. *<br>输入参数:int iTemp 删除数据的位置
    48. *<br>输出变量:Vector
    49. *<br>其它说明:如果删除超界的数据,将返回null
    50. */
    51. public Vector<Object> delete(Vector<Object> vTemp,int iTemp){
    52. if(iTemp>vTemp.size()){
    53. print("数据超界!");
    54. return null;
    55. }else{
    56. vTemp.removeElementAt(iTemp);
    57. }
    58. return vTemp;
    59. }
    60. /*
    61. *<br>方法说明:修改数据
    62. *<br>输入参数:Vector vTemp 待修改矢量对象
    63. *<br>输入参数:int iTemp 修改数据的位置
    64. *<br>输入参数:Object oTemp 修改数据值
    65. *<br>输出变量:Vector
    66. *<br>其它说明:如果修改位置超界的数据,将返回null
    67. */
    68. public Vector<Object> updata(Vector<Object> vTemp,int iTemp,Object oTemp){
    69. if(iTemp>vTemp.size()){
    70. print("数据超界!");
    71. return null;
    72. }else{
    73. vTemp.setElementAt(oTemp,iTemp);
    74. }
    75. return vTemp;
    76. }
    77. /*
    78. *<br>方法说明:输出信息
    79. *<br>输入参数:String sTemp 输出信息名称
    80. *<br>输入参数:Object oTemp 输出信息值
    81. *<br>返回变量:无
    82. */
    83. public void print(String sTemp,Vector<Object> oTemp){
    84. System.out.println(sTemp+"数据:");
    85. this.print(oTemp);
    86. }
    87. /**
    88. *<br>方法说明:打印输出(过载)
    89. *<br>输入参数:Object oPara 输出的对象
    90. *<br>返回类型:无
    91. */
    92. public void print(Object oPara){
    93. System.out.println(oPara);
    94. }
    95. /**
    96. *<br>方法说明:打印输出(过载)
    97. *<br>输入参数:Vector vPara 显示输出矢量对象
    98. *<br>返回类型:无
    99. */
    100. public void print(Vector<Object> vPara){
    101. for(int i=0;i<vPara.size();i++){
    102. System.out.println(vPara.elementAt(i));
    103. }
    104. }
    105. /**
    106. *<br>方法说明:主方法,程序入口
    107. *<br>输入参数:String[] args
    108. *<br>返回类型:无
    109. */
    110. public static void main(String[] args)
    111. {
    112. operateVector ov = new operateVector();
    113. Vector<Object> vTemp = ov.buildVector();
    114. ov.print("vTemp0",vTemp);
    115. Vector<Object> vResult = ov.insert(vTemp,2,"添加的数据");
    116. ov.print("vResult",vResult);
    117. Vector<Object> vResultup = ov.updata(vResult,2,"修改的数据");
    118. ov.print("vResultmp",vResultup);
    119. Vector<Object> vResultnow = ov.delete(vResultup,2);
    120. ov.print("vResultnow",vResultnow);
    121. }
    122. }

    1. package test5;
    2. import java.util.*;
    3. /**
    4. * Title: 哈希表操作
    5. * Description: 这是一个权限认证的例子,使用了哈希表作为数据的存储
    6. * Filename: RoleRight.java
    7. */
    8. public class RoleRight
    9. {
    10. private static Hashtable<String, String> rightList = new Hashtable<String, String>();
    11. /**
    12. *<br>方法说明:初始化数据
    13. *<br>输入参数:
    14. *<br>返回类型:
    15. */
    16. public void init()
    17. {
    18. String[] accRoleList = {"admin","satrap","manager","user","guest"};
    19. String[] rightCodeList = {"10001","10011","10021","20011","24011"};
    20. for(int i=0;i<accRoleList.length;i++)
    21. {
    22. rightList.put(accRoleList[i],rightCodeList[i]);
    23. }
    24. }
    25. /**
    26. *<br>方法说明:获取角色权限代码
    27. *<br>输入参数:String accRole 角色名称
    28. *<br>返回类型:String 权限代码
    29. */
    30. public String getRight(String accRole)
    31. {
    32. if(rightList.containsKey(accRole))
    33. return (String)rightList.get(accRole);
    34. else
    35. return null;
    36. }
    37. /**
    38. *<br>方法说明:添加角色和代码信息
    39. *<br>输入参数:String accRole 角色名称
    40. *<br>输入参数:String rightCode 角色权限代码
    41. *<br>返回类型:void (无)
    42. */
    43. public void insert(String accRole,String rightCode)
    44. {
    45. rightList.put(accRole,rightCode);
    46. }
    47. /**
    48. *<br>方法说明:删除角色权限
    49. *<br>输入参数:String accRole 角色名称
    50. *<br>返回类型:void(无)
    51. */
    52. public void delete(String accRole)
    53. {
    54. if(rightList.containsKey(accRole))
    55. rightList.remove(accRole);
    56. }
    57. /**
    58. *<br>方法说明:修改角色权限代码
    59. *<br>输入参数:String accRole 角色名称
    60. *<br>输入参数:String rightCode 角色权限代码
    61. *<br>返回类型:void(无)
    62. */
    63. public void update(String accRole,String rightCode)
    64. {
    65. //this.delete(accRole);
    66. this.insert(accRole,rightCode);
    67. }
    68. /**
    69. *<br>方法说明:打印哈希表中角色和代码对应表
    70. *<br>输入参数:无
    71. *<br>返回类型:无
    72. */
    73. public void print()
    74. {
    75. Enumeration<String> RLKey = rightList.keys();
    76. while(RLKey.hasMoreElements())
    77. {
    78. String accRole = RLKey.nextElement().toString();
    79. print(accRole+"="+this.getRight(accRole));
    80. }
    81. }
    82. /**
    83. *<br>方法说明:打印信息(过载)
    84. *<br>输入参数:Object oPara 打印的信息内容
    85. *<br>返回类型:无
    86. */
    87. public void print(Object oPara)
    88. {
    89. System.out.println(oPara);
    90. }
    91. /**
    92. *<br>方法说明:主方法,
    93. *<br>输入参数:
    94. *<br>返回类型:
    95. */
    96. public static void main(String[] args)
    97. {
    98. RoleRight RR = new RoleRight();
    99. RR.init();
    100. RR.print();
    101. RR.print("___________________________");
    102. RR.insert("presider","10110");
    103. RR.print();
    104. RR.print("___________________________");
    105. RR.update("presider","10100");
    106. RR.print();
    107. RR.print("___________________________");
    108. RR.delete("presider");
    109. RR.print();
    110. }
    111. }//end:)~

    1. package test6;
    2. /**
    3. * Title: 树参数
    4. * Description: 使用继承类,柳树就是树
    5. * Filename: osier.java
    6. */
    7. class tree
    8. {
    9. /**
    10. *<br>方法说明:树的树根
    11. */
    12. public void root()
    13. {
    14. String sSite = "土壤中";
    15. String sFunction = "吸收养份";
    16. print("位置:"+sSite);
    17. print("功能:"+sFunction);
    18. }
    19. /**
    20. *方法说明:树的树干
    21. */
    22. public void bolo()
    23. {
    24. String sSite = "地面";
    25. String sFunction = "传递养份";
    26. print("位置:"+sSite);
    27. print("功能:"+sFunction);
    28. }
    29. /**
    30. *方法说明:树的树枝
    31. */
    32. public void branch()
    33. {
    34. String sSite = "树干上";
    35. String sFunction = "传递养份";
    36. print("位置:"+sSite);
    37. print("功能:"+sFunction);
    38. }
    39. /**
    40. *方法说明:树的叶子
    41. */
    42. public void leaf()
    43. {
    44. String sSite = "树梢";
    45. String sFunction = "光合作用";
    46. String sColor = "绿色";
    47. print("位置:"+sSite);
    48. print("功能:"+sFunction);
    49. print("颜色:"+sColor);
    50. }
    51. /**
    52. *方法说明:显示信息
    53. *输入参数:Object oPara 显示的信息
    54. */
    55. public void print(Object oPara)
    56. {
    57. System.out.println(oPara);
    58. }
    59. /**
    60. *方法说明:主方法:
    61. */
    62. public static void main(String[] arges)
    63. {
    64. tree t = new tree();
    65. t.print("描述一棵树:");
    66. t.print("树根:");
    67. t.root();
    68. t.print("树干:");
    69. t.bolo();
    70. t.print("树枝:");
    71. t.branch();
    72. t.print("树叶:");
    73. t.leaf();
    74. }
    75. }
    76. /**
    77. * Title: 柳树参数
    78. * Description: 描述柳树的参数
    79. */
    80. class osier extends tree
    81. {
    82. /**
    83. *方法说明:过载树的树叶
    84. */
    85. public void leaf()
    86. {
    87. super.leaf();
    88. String sShape = "长形";
    89. super.print("形状:"+sShape);
    90. }
    91. /**
    92. *方法说明:扩展树的花
    93. */
    94. public void flower()
    95. {
    96. print("哈哈,柳树没有花!!");
    97. }
    98. /**
    99. *方法说明:主方法
    100. */
    101. public static void main(String[] args)
    102. {
    103. osier o = new osier();
    104. o.print("柳树树根:");
    105. o.root();
    106. o.print("柳树树干:");
    107. o.bolo();
    108. o.print("柳树树枝:");
    109. o.branch();
    110. o.print("柳树树叶:");
    111. o.leaf();
    112. o.print("柳树花:");
    113. o.flower();
    114. }
    115. }

    1. package test7;
    2. /**
    3. * Title: 接口和抽象函数
    4. * Description: 演示继承抽象函数和实现接口
    5. * Filename: newPlay.java
    6. */
    7. //接口
    8. interface player
    9. {
    10. int flag = 1;
    11. void play();//播放
    12. void pause();//暂停
    13. void stop();//停止
    14. }//end :)
    15. //抽象类
    16. abstract class playing
    17. {
    18. public void display(Object oPara)
    19. {
    20. System.out.println(oPara);
    21. }
    22. abstract void winRun();
    23. }//end :)
    24. //继承了playing抽象类和实现类player接口
    25. public class newPlay extends playing implements player
    26. {
    27. public void play()
    28. {
    29. display("newPlay.play()");//这里只是演示,去掉了代码。
    30. }
    31. public void pause()
    32. {
    33. display("newPlay.pause()");//这里只是演示,去掉了代码。
    34. }
    35. public void stop()
    36. {
    37. display("newPlay.stop()");//这里只是演示,去掉了代码。
    38. }
    39. void winRun()
    40. {
    41. display("newPlay.winRun()");//这里只是演示,去掉了代码。
    42. }
    43. public static void main(String[] args)
    44. {
    45. newPlay p = new newPlay();
    46. p.play();
    47. p.pause();
    48. p.stop();
    49. p.winRun();
    50. }
    51. }//end :)

    1. package test8.com;
    2. /**
    3. * Title: 标识符
    4. * Description: 演示标识符对类的访问控制
    5. * Filename:
    6. */
    7. public class classDemo1 {
    8. // 公有方法
    9. public void mechod1() {
    10. System.out.println("这是一个公有的方法!任何类都可以访问。");
    11. }
    12. // 授保护的方法
    13. protected void mechod2() {
    14. System.out.println("这是一个受到保护的方法!只有子类可以访问。");
    15. }
    16. // 私有的方法
    17. private void mechod3() {
    18. System.out.println("这是一个私有的方法!只有类本身才可以访问。");
    19. }
    20. public static void main(String[] args) {
    21. classDemo1 d = new classDemo1();
    22. d.mechod1();
    23. d.mechod2();
    24. d.mechod3();
    25. }
    26. }

    1. package test8.com;
    2. /**
    3. * Title: 标识符
    4. * Description: 演示标识符对类的访问控制
    5. * Filename:
    6. */
    7. public class classPlay
    8. {
    9. public static void main(String[] args){
    10. classDemo1 d = new classDemo1();
    11. d.mechod1();
    12. d.mechod2();
    13. //d.mechod3();
    14. }
    15. }

    1. package test8.net;
    2. import test8.com.classDemo1;
    3. /**
    4. * Title: 标识符
    5. * Description: 演示标识符对类的访问控制
    6. * Filename:
    7. */
    8. public class classPlay
    9. {
    10. public static void main(String[] args){
    11. classDemo1 d = new classDemo1();
    12. d.mechod1();
    13. //d.mechod2();
    14. //d.mechod3();
    15. }
    16. }


    1. package test9;
    2. /**
    3. * Title: 捕获异常和实现自己的异常
    4. * Description: 通过继承Exception类来实现自己的异常类。并使用try-catch来捕获这个异常。
    5. * Filename:
    6. */
    7. class MyException extends Exception {
    8. private static final long serialVersionUID = 1L;
    9. public MyException() {
    10. }
    11. public MyException(String msg) {
    12. super(msg);
    13. }
    14. public MyException(String msg, int x) {
    15. super(msg);
    16. i = x;
    17. }
    18. public int val() {
    19. return i;
    20. }
    21. private int i;
    22. }
    23. public class DemoException {
    24. /**
    25. *方法说明:使用MyException类中默认的构造器
    26. */
    27. public static void a() throws MyException {
    28. System.out.println("Throwing MyException from a()");
    29. throw new MyException();
    30. }
    31. /**
    32. *方法说明:使用MyException类中带信息的构造器
    33. */
    34. public static void b() throws MyException {
    35. System.out.println("Throwing MyException from b()");
    36. throw new MyException("Originated in b()");
    37. }
    38. /**
    39. *方法说明:使用了MyException中有编码的构造器
    40. */
    41. public static void c() throws MyException {
    42. System.out.println("Throwing MyException from c()");
    43. throw new MyException("Originated in c()", 47);
    44. }
    45. public static void main(String[] args) {
    46. try {
    47. a();
    48. } catch (MyException e) {
    49. e.getMessage();
    50. }
    51. try {
    52. b();
    53. } catch (MyException e) {
    54. e.toString();
    55. }
    56. try {
    57. c();
    58. } catch (MyException e) {
    59. e.printStackTrace();
    60. System.out.println("error code: " + e.val());
    61. }
    62. }
    63. } // end :)

    1. package test10;
    2. import javax.swing.*;
    3. import java.awt.*;
    4. /**
    5. * Title: 创建自己的窗体
    6. * Description:
    7. * Filename:mainFrame.java
    8. */
    9. public class mainFrame extends JFrame {
    10. private static final long serialVersionUID = 1L;
    11. /**
    12. *方法说明:构造器,通过传递参数来完成窗体的绘制。
    13. *输入参数:String sTitle 窗体标题
    14. *输入参数:int iWidth 窗体的宽度
    15. *输入参数:int iHeight 窗体的高度 返回类型:
    16. */
    17. public mainFrame(String sTitle, int iWidth, int iHeight) {
    18. Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();// 获取屏幕尺寸
    19. ImageIcon ii = new ImageIcon("middle.gif");
    20. setTitle(sTitle);// 设置窗体标题
    21. setIconImage(ii.getImage());// 设置窗体的图标
    22. setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);// 设置但关闭窗体时退出程序
    23. setSize(iWidth, iHeight);// 设置窗体大小
    24. int w = getSize().width;// 获取窗体宽度
    25. int h = getSize().height;// 获取窗体高度
    26. System.out.println("窗体宽:" + w + " 窗体高:" + h);
    27. int x = (dim.width - w) / 2;
    28. int y = (dim.height - h) / 2;
    29. setLocation(x, y);// 将窗体移到屏幕中间
    30. setVisible(true);// 显示窗体
    31. }
    32. public static void main(String[] args) {
    33. JFrame.setDefaultLookAndFeelDecorated(true);// 使用最新的SWING外观
    34. new mainFrame("main Frame Demo", 400, 300);
    35. }
    36. }



    展开全文
  • 单例模式实例(全)

    2020-06-23 10:57:38
    定义:确保一个类只有一个实例,而且自行实例化并向整个系统提供这个实例场景,也就是说:确保某个类有且只有一个对象的场景,避免产生多个对象消耗过多的资源,或者某种类型的对象应该有且只有一个。 构建单例模式...
  • 23种设计模式 参考博客:... ... java的设计模式大体上分为三大类: 创建型模式(5种):工厂方法模式,抽象工厂模式,单例模式,建造者模式,原型模式。 结构型模式(7种):适配器模...
  • 实例分割:机器自动从图像中用目标检测方法框出不同实例,再用语义分割方法在不同实例区域内进行逐像素标记 借一个浅显的说法:语义分割不区分属于相同类别的不同实例。例如,当图像中有多只猫时,语义分割会将...
  • 实例(instance) 在面向对象程序设计中,“类”在实例化之后叫做一个“实例”。 “类”是静态的,不占进程内存,而“实例”拥有动态内存。 在数据库中,代表一些程序的集合。如Oracle中,实例就是一些能支撑数据库...
  • github:https://github.com/jiasion/eslog wechat:minghui-666 利用redisson实现多实例抢占定时任务 pom.xml <dependency> <groupId>org.redisson</groupId> <artifactId>r...
  • 实例化一个对象时,JVM首先会检查相关类型是否已经加载并初始化,如果没有,则JVM立即进行加载并调用类构造器完成类的初始化。在类初始化过程中或初始化完毕后,根据具体情况才会去对类进行实例化。本文试图对JVM...
  • Python进阶(十一)-定义实例方法  一个实例的私有属性就是以__开头的属性,无法被外部访问。那这些属性定义有什么用?   虽然私有属性无法从外部访问,但是,从类的内部是可以访问的。除了可以定义实例的属性外...
  • 查看SQL Server的实例

    2018-01-30 16:08:18
     数据库的实例名是指每个数据库的名称,应该是在数据库安装的时候确定的,分为默认实例(Default Instance)和命名实例(Named Instance)。  一般在安装时,选择默认实例,那么就是用计算机的名字来作为实例名,...
  • 在我讲解的案例中,经常一个工程启动多个实例,分别占用不同的端口,有很多读者百思不得其解,在博客上留言,给我发邮件,加我微信询问。所以有必要在博客上记录下,方便读者。step 1在IDEA上点击Application右边的...
  • 一、网络上的一般说法1、ViewState 对象为Null。2、DateSet 空。3、sql语句或Datebase的原因导致DataReader空。4、声明字符串变量时未赋空值就应用...10、重复定义造成未将对象引用设置到对象的实例错误. 二、 (1)所
  • 很多人都把这两个概念弄混淆,认为MySQL是数据库,也是数据库实例。这样的理解在应用到Oracle和SQL Server的时候可能是正确的,但是再MySQL的体系结构中确是不适用的。 那么从概念上理解,该如何区分数据库和数据库...
  • 清除AWS实例和卷

    2015-06-11 11:39:27
    清除您的实例和卷在您完成为本教程创建的实例和 Amazon EBS 卷后,应进行清除。首先,终止实例,使卷与实例分离,然后删除卷。因为您无法在终止实例后重新连接到实例,所以终止实例可进行有效删除。这不同于停止实例...
  • java多线程编程实例

    2018-05-25 10:01:22
    这篇文章主要介绍了java多线程编程实例,分享了几则多线程的实例代码,具有一定参考价值,加深多线程编程的理解还是很有帮助的,需要的朋友可以参考下。1.相关知识:Java多线程程序设计到的知识:(1)对同一个数量...
1 2 3 4 5 ... 20
收藏数 3,919,839
精华内容 1,567,935
关键字:

实例