【原】Java学习笔记016

 package cn.temptation;
 
 public class Sample01 {
     public static void main(String[] args) {
         // this 关键字 的使用
 
         Student student = new Student();
         student.setName("张三");
         System.out.println(student.getName());
     }
 }
 
 // 学生类
 class Student {
     // 成员变量
     private String name;
 
     // 构造函数
 
     // 成员方法
     // 因为觉得参数叫name这个变量名比较好听，setXXX方法中形参也想使用name这个变量名，可以么？
 //    public void setName(String studentName) {
 //        name = studentName;
 //    }
 
     public void setName(String name) {
         // 产生警告：The assignment to variable name has no effect
         // 这里就搞不清楚了，到底是把成员变量的name赋值给了形参的name，还是把形参的name赋值给了成员变量的name？
         // 回想一下  对象名.成员变量   或者 对象名.成员方法，在这里把形参的name赋值给了成员变量的name
         // 也就是说下句中前面的name如果能标明是成员变量的name就没有问题了
 //        name = name;
 
         // 考虑在setXXX方法中创建一个对象，把形参的name赋值给创建出来的对象的成员变量name，但是这样写还是有问题的
         // 因为在setXXX方法中创建出的这个对象 和 主函数中创建的对象不是一个对象，主函数中创建的对象获取其成员变量时还是得到默认值null的
 //        Student student = new Student();
 //        student.name = name;
 
         // 使用  this 关键字，表明把形参的name赋值给当前这个对象的成员变量name，这个this指的就是当前的这个对象
         // 通过设置断点查看到，下句的this的值为：cn.temptation.Student@7fbe847c
         // 和主函数中创建出的对象值为：cn.temptation.Student@7fbe847c      相同
         this.name = name;
 
         // 注意：
         // 上句中赋值号右侧的name根据变量调用原则：就近原则，就近找到了局部变量name的定义，它是局部变量
         // 赋值号左侧的name根据this这个当前对象的点号运算符访问到了成员变量name
     }
 
     public String getName() {
         // 下句中的name根据变量调用原则：就近原则，所以其为成员变量
 //        return name;
 
         // 下句的name根据this这个当前对象的点号运算符访问到了成员变量name，效果和上句相同
         return this.name;
     }
 }

 package cn.temptation;
 
 public class Sample02 {
     public static void main(String[] args) {
         // 通过IDE自动生成getXXX和setXXX方法
         // 方式1：alt+shift+s、alt+shift+r
         // 方式2：菜单项或右键，找到Source，再找到Generate getters and setters...
 
         // 通过IDE自动生成构造函数
         // 方式1：alt+shift+s、alt+shift+o
         // 方式2：菜单项或右键，找到Source，再找到Generate constructor using Fields...
     }
 }
 
 // 员工类
 class Employee {
     // 成员变量
     private String name;
     private int age;
 
     // 构造函数
     public Employee() {
 
     }
 
     public Employee(String name, int age) {
         this.name = name;
         this.age = age;
     }
 
     // 成员方法
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getAge() {
         return age;
     }
 
     public void setAge(int age) {
         this.age = age;
     }
 }

 package cn.temptation;
 
 public class Sample03 {
     public static void main(String[] args) {
 //        Person person1 = new Person();
 //        person1.setName("张三");
 ////        person1.setCountry("中国");
 //        System.out.println("姓名为：" + person1.getName() + "，国籍为：" + person1.getCountry());
 //
 //        Person person2 = new Person();
 //        person2.setName("李四");
 ////        person2.setCountry("中国");
 //        System.out.println("姓名为：" + person2.getName() + "，国籍为：" + person2.getCountry());
 
         // 发现问题：创建了若干个Person对象，他们的country这个成员变量都是"中国"，需要进行很多次setCountry赋值
         // 对于一系列对象具有相同的成员变量值，是否有便捷的处理方式？
         // 方式1、对成员变量使用指定的默认值，方法可行
         // 方式2、既然是描述一系列对象的相同的成员变量值，换句话说就是对象们的成员变量值，再抽象一步，对象们的抽象----->类
 
         // 引入静态的概念：static 关键字
         // static关键字可以用于成员变量 和 成员方法。用在成员变量上，成员变量就是静态成员变量；用在成员方法上，成员方法就是静态成员方法。
 
         // static的格式：
         // 静态成员变量： static    数据类型      变量名;
         // 静态成员方法：修饰符   static   返回类型   方法名(参数列表) { ... }
 
         // 使用static修饰成员变量后，对某一个对象设置了静态成员变量的值，其他没有被设置静态成员变量的对象也具有了相同的值（注意：对象们的含义）
 //        Person person3 = new Person();
 //        person3.setName("王五");
 //        person3.country = "中国";
 //        System.out.println("姓名为：" + person3.getName() + "，国籍为：" + person3.country);
 //
 //        Person person4 = new Person();
 //        person4.setName("赵六");
 //        System.out.println("姓名为：" + person4.getName() + "，国籍为：" + person4.country);
 
         // 使用static修饰成员变量后，使用  类名.静态成员变量名  可以访问到静态成员变量，可以不创建对象
 //        Person.country = "中国";
 //
 //        // 再创建对象，对象的静态成员变量的值   等同于使用   类名.静态成员变量  设置的值
 //        Person person5 = new Person();
 //        person5.setName("钱七");
 //        // 下面两句效果相同
 //        System.out.println("姓名为：" + person5.getName() + "，国籍为：" + person5.country);
 //        System.out.println("姓名为：" + person5.getName() + "，国籍为：" + Person.country);
 //
 //        Person person6 = new Person();
 //        person6.setName("王八");
 //        // 下面两句效果相同
 //        System.out.println("姓名为：" + person6.getName() + "，国籍为：" + person6.country);
 //        System.out.println("姓名为：" + person6.getName() + "，国籍为：" + Person.country);
     }
 }
 
 //// 人类
 //class Person {
 //    // 成员变量
 //    private String name;
 ////    private String country;
 ////    private String country = "中国";
 //    public static String country;
 //
 //    // 成员方法
 //    public String getName() {
 //        return name;
 //    }
 //
 //    public void setName(String name) {
 //        this.name = name;
 //    }
 //
 ////    public String getCountry() {
 ////        return country;
 ////    }
 ////
 ////    public void setCountry(String country) {
 ////        this.country = country;
 ////    }
 //}

 package cn.temptation;
 
 public class Sample04 {
     public static void main(String[] args) {
         // static的特点：
         // 1、static修饰的成员伴随着类被类加载器（classloader）加载而加载的
         // 2、static修饰的这些成员变量  和  成员方法，出现的时间比对象要早（理解：只要是在大陆出生的，还没出生就确定了你的国籍是中国的）
         // 3、static描述的是类的特征 和 行为，也是对象们都具有的特征  和 行为
         // 4、static使用时，可以使用   对象名.静态成员，也可以使用  类名.静态成员，建议使用  类名.静态成员
 
         // 类名.非静态成员变量，产生语法错误
         // 语法错误：Cannot make a static reference to the non-static field Test.i
 //        System.out.println(Test.i);
         // 对象名.非静态成员变量，语法正确
 //        Test test = new Test();
 //        System.out.println(test.i);
 //
 //        // 类名.静态成员变量，语法正确
 //        System.out.println(Test.j);
 //
 //        Test.j = 4;
 //
 //        Test testEx = new Test();
 //        // 对象名.静态成员变量，语法正确
 //        System.out.println(testEx.j);
 //        // 类名.静态成员变量，语法正确（推荐写法）
 //        System.out.println(Test.j);
     }
 }
 
 //class Test {
 //    int i = 2;
 //    static int j = 3;
 //}

 package cn.temptation;
 
 public class Sample05 {
     public static void main(String[] args) {
         // 成员变量设置为static，其相应的封装方法也需要设置为static，否则静态成员变量在类加载时就被加载的，却因为对应的封装方法不是static的而无法使用
 //        Baby.setCountry("中国");
 //
 //        Baby baby = new Baby();
 //        baby.setName("张三");
 //        System.out.println("姓名为：" + baby.getName() + "，国籍为：" + Baby.getCountry());
     }
 }
 
 //class Baby {
 //    // 成员变量
 //    private String name;
 //    private static String country;
 //
 //    // 成员方法
 //    public String getName() {
 //        return name;
 //    }
 //
 //    public void setName(String name) {
 //        this.name = name;
 //    }
 //
 //    public static String getCountry() {
 //        return country;
 //    }
 //
 //    public static void setCountry(String country) {
 //        // 明确显示的指出把局部变量形参赋值给  类名.静态成员变量
 //        Baby.country = country;
 //
 //        // 语法错误：Cannot use this in a static context     不能在一个static上下文环境中使用this
 //        // 这里为什么不能使用this？    答：因为this指的是当前这个对象，既不是对象们，也不是类
 ////        this.country = country;
 //    }
 //
 //}

 package cn.temptation;
 
 public class Sample06 {
     public static void main(String[] args) {
         // static关键不但可以用在成员变量上，也可以使用在成员方法上
 
         // 访问性问题
         /*
          * 1、静态成员方法
          *         只能访问静态的成员变量   和    静态的成员方法
          *         不能访问非静态的成员变量   和   非 静态的成员方法
          * 2、非静态成员方法
          *         能访问静态的成员变量   和    静态的成员方法
          *         能访问非静态的成员变量   和   非 静态的成员方法
          *
          * 总结：    静态的只能访问静态的，非静态的都可以访问
          */
     }
 }
 
 class Demo {
     // 成员变量
     // 非静态的成员变量
     int i = 2;
     // 静态的成员变量
     static int j = 3;
 
     // 成员方法
     // 非静态的成员方法
     public void method1() {
         System.out.println(i);
         System.out.println(j);
 
         method2();
         method3();
     }
 
     public void method2() {
 
     }
 
     // 静态的成员方法
     public static void method3() {
         // 语法错误：Cannot make a static reference to the non-static field i
 //        System.out.println(i);
         System.out.println(j);
 
         // 语法错误：Cannot make a static reference to the non-static method method1() from the type Demo
 //        method1();
         method4();
     }
 
     public static void method4() {
 
     }
 }

 package cn.temptation;        // 在命令行窗口下编译执行，这句先注释掉
 
 public class Sample07 {
     public static void main(String[] args) {
         // main主函数（主方法）
         // 1、public：公开的，可访问权限最大
         // 2、static：静态的，静态的main方法被JVM调用（因为这个main方法是Java程序的入口），调用会是一种什么形式？
         //         形式1、Sample07  对象名    = new Sample07();      对象名.main();
         //         形式2、Sample07.main();
         //         调用时，JVM自然不会先去创建一个Sample07对象的，必然是形式2，形式2需要成员方法使用static修饰，所以main主函数使用static关键字修饰
         // 3、void：无返回的，JVM不需要返回什么
         // 4、main：使用main作为主函数的方法名是一种约定
         // 5、String[] args：在Java早期使用的，用来在命令行窗口中接收命令行的参数的输入
 
 //        System.out.println(args);                // [Ljava.lang.String;@15db9742
 //        System.out.println(args.length);        // 0
 
         // 使用javac对当前代码文件进行编译，再使用java Sample07 "字符串1" "字符串2" "字符串3"，可以看到命令行窗口中显示出参数列表的值
         for (String item : args) {
             System.out.println(item);
         }
     }
 }

 package cn.temptation;
 
 public class Sample08 {
     public static void main(String[] args) {
         // 大括号的玩法总结
         // 代码块：Java中，使用大括号{}将语句包含其中，称为代码块
 
         // 1、局部代码块（联想到局部变量）
         // 位置：在方法内
         // 作用：限定变量的作用范围
 
         // 2、构造代码块（联想到构造函数）
         // 位置：在类中，和成员变量、成员方法、构造函数同级的位置
         // 作用：从构造代码块的执行效果看，因为它的执行在构造函数之前，所以可以考虑把构造函数及其重载方法中相同的语句提取出来放在构造代码块中
 
         // 3、静态代码块（联想到静态成员）
         // 位置：在类中，和成员变量、成员方法、构造函数、构造代码块同级的位置
         // 作用：从静态代码块的执行效果看，静态代码块中的语句比构造代码块中的语句还要先执行，且只执行一次
         //        常常用于先于构造代码块等执行且只执行一次语句的场合，比如：数据库连接
 
         // 局部代码块
 //        {
 //            // 局部变量的声明和赋值在局部代码块内部
 //            int i = 2;
 //            System.out.println(i);
 //        }
         // 局部代码块限定了其中的局部变量i的作用域，使得在局部代码块外的语句无法访问在局部代码块内声明的变量
         // 语法错误：i cannot be resolved to a variable
 //        System.out.println(i);
 
 //        int j = 3;
 //        System.out.println(j);
 //        {
 //            // 修改局部变量赋值在局部代码块内部
 //            j = 4;
 //            System.out.println(j);
 //        }
 //        // 局部代码块外的语句可以访问在局部代码块外声明且在局部代码块内部修改赋值的变量
 //        System.out.println(j);
 
         // 创建一个Test类类型的对象
         Test test = new Test();
 
         // 再创建一个Test类类型的对象
         Test testEx = new Test();
     }
 
     // 静态代码块
     static {
         System.out.println("这是Sample08类中的静态代码块");
     }
 
     // 注意：Sample08类中的静态代码块的显示先于Test类中的静态代码块的显示，这是因为类的加载先后顺序决定的（程序入口main主函数所在的类先被加载）
 }
 
 class Test {
     // 成员变量
     private int number;
 
     // 构造函数（无参）
     public Test() {
         System.out.println("这是无参构造函数");
         // 因为不知道会执行哪一种构造函数的形式，所以每种构造函数中都要进行对成员变量的赋值操作
 //        this.number = 123;
     }
 
     // 构造函数（有参）
     public Test(int number) {
         System.out.println("这是有参构造函数");
         // 因为不知道会执行哪一种构造函数的形式，所以每种构造函数中都要进行对成员变量的赋值操作
 //        this.number = 123;
     }
 
     // 构造代码块
     {
         System.out.println("这是构造代码块");
         // 在构造代码块中编写构造函数及其重载方法中都有的语句，这样可以节省大量的重复代码
         this.number = 123;
     }
 
     // 静态代码块
     static {
         System.out.println("这是静态代码块");
     }
 
     // 成员方法
 }

 package cn.temptation;
 
 public class Sample09 {
     public static void main(String[] args) {
 //        Man man = new Man();
 //        man.setName("吕布");
 //        man.setAge(20);
 //        man.eat();
 //        man.earn();
 //
 //        Woman woman = new Woman();
 //        woman.setName("貂蝉");
 //        woman.setAge(16);
 //        woman.eat();
 //        woman.pay();
 
         // 发现问题：原先Man类 和 Woman类所特有的行为，在Person类上都不再是特有的了，这种Person类的设计扩大了行为能力
 //        Person person1 = new Person();
 //        person1.setName("吕布");
 //        person1.setAge(20);
 //        person1.eat();
 //        person1.earn();
 //        person1.pay();
     }
 }
 
 //// 男人类
 //class Man {
 //    // 成员变量
 //    private String name;
 //    private int age;
 //
 //    // 成员方法
 //    public String getName() {
 //        return name;
 //    }
 //
 //    public void setName(String name) {
 //        this.name = name;
 //    }
 //
 //    public int getAge() {
 //        return age;
 //    }
 //
 //    public void setAge(int age) {
 //        this.age = age;
 //    }
 //
 //    // 自定义成员方法
 //    public void eat() {
 //        System.out.println("吃饭");
 //    }
 //
 //    public void earn() {
 //        System.out.println("赚钱");
 //    }
 //}
 //
 //// 女人类
 //class Woman {
 //    // 成员变量
 //    private String name;
 //    private int age;
 //
 //    // 成员方法
 //    public String getName() {
 //        return name;
 //    }
 //
 //    public void setName(String name) {
 //        this.name = name;
 //    }
 //
 //    public int getAge() {
 //        return age;
 //    }
 //
 //    public void setAge(int age) {
 //        this.age = age;
 //    }
 //
 //    // 自定义成员方法
 //    public void eat() {
 //        System.out.println("吃饭");
 //    }
 //
 //    public void pay() {
 //        System.out.println("花钱");
 //    }
 //}
 
 // 观察Man类  和  Woman类的代码中有太多相同的代码，所以我们考虑不使用两个类去表示，就用一个类表示，考虑男人类、女人类都是人类
 //class Person {
 //    // 成员变量
 //    private String name;
 //    private int age;
 //
 //    // 成员方法
 //    public String getName() {
 //        return name;
 //    }
 //
 //    public void setName(String name) {
 //        this.name = name;
 //    }
 //
 //    public int getAge() {
 //        return age;
 //    }
 //
 //    public void setAge(int age) {
 //        this.age = age;
 //    }
 //
 //    // 自定义成员方法
 //    public void eat() {
 //        System.out.println("吃饭");
 //    }
 //
 //    public void earn() {
 //        System.out.println("赚钱");
 //    }
 //
 //    public void pay() {
 //        System.out.println("花钱");
 //    }
 //}

 package cn.temptation;
 
 public class Sample10 {
     public static void main(String[] args) {
         // 想把若干个不同的类的相同的成员变量和成员方法提取出来做抽象，形成一个更高级别的抽象的类
         // 但是它们的不同的成员变量和成员方法如何使用？
 
         // Java中提供了   继承   的机制
 
         // 面向对象的三大特点：
         // 1、封装性：encapsulation
         // 2、继承性：inheritance
         // 3、多态性：polymorphism
 
         // 继承的格式：    子类   extends  父类
 
         // 1、将子类中相同的成员变量 和  成员方法都抽取出来放在父类中，减少子类中的代码
         // 2、通过extends关键字，让子类使用父类中的这些相同的成员变量和成员方法，这样和把这些成员写在子类中效果相同
 
         Man man = new Man();
         man.setName("吕布");
         man.setAge(20);
         man.eat();
         man.earn();
         // 语法错误：The method pay() is undefined for the type Man
 //        man.pay();
 
         Woman woman = new Woman();
         woman.setName("貂蝉");
         woman.setAge(16);
         woman.eat();
         woman.pay();
         // 语法错误：The method earn() is undefined for the type Woman
 //        woman.earn();
 
         // 子类从父类继承而来，自然把父类的成员变量 和 成员方法都一股脑儿拿来使用
 
         // 【继承的优点】
         // 1、减少了代码量
         // 2、方便了修改
         // 3、丰富了类和类之间的关系
 
         // 【继承的缺点】
         // 1、继承是无法选择（不论子类要还是不要，只要继承了，都给子类了）
         // 2、类与类之间形成了较强的耦合度
 
         // 【设计的原则：好的设计，追求的是"高内聚、低耦合"】
 
         // 中国古代士大夫的自我准则：修身、齐家、平天下
         // 做好面向对象的设计准则：同上
     }
 }
 
 // 人类
 class Person {
     // 成员变量
     private String name;
     private int age;
 
     // 成员方法
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getAge() {
         return age;
     }
 
     public void setAge(int age) {
         this.age = age;
     }
 
     // 自定义的成员方法
     public void eat() {
         System.out.println("吃饭");
     }
 }
 
 // 男人类
 class Man extends Person {
     // 成员变量
 
     // 成员方法
     public void earn() {
         System.out.println("赚钱");
     }
 }
 
 // 女人类
 class Woman extends Person {
     // 成员变量
 
     // 成员方法
     public void pay() {
         System.out.println("花钱");
     }
 }

 package cn.temptation;
 
 public class Sample11 {
     public static void main(String[] args) {
         // 继承的特点：
         // Java中的继承是单继承，不是多继承（指的是类的继承），多继承在现实世界中是可以的，比如：小孩从父母双方继承基因
 
         // 理解单继承：
         // 1、被继承的类是单个的
         // 2、继承并不只有一层，可以是多层的（也就是继承链），但是继承链上的每一层都是单继承
     }
 }
 
 //class GrandFather {
 //
 //}
 //
 //class Father extends GrandFather {
 //
 //}
 //
 //class Mother {
 //
 //}
 //
 //class Baby extends Father {        // 语法OK
 ////class Baby extends Mother {        // 语法OK
 ////class Baby extends Father, Mother {    // 语法出错
 ////class Baby extends Father + Mother {    // 语法出错
 ////class Baby extends Father Mother {        // 语法出错
 //
 //}

 package cn.temptation;
 
 public class Sample12 {
     public static void main(String[] args) {
         // 继承是可以传递的
         // 只要在继承链上，链的下级可以得到上级及上级的上级的...成员变量 和 成员方法（对上级的查找是一直向上直到继承链的源头）
 
         // 通过继承链得到成员的缺点：当前类的对象使用成员时，不知道自身的成员变量或成员方法到底来自于哪一个上级
         // IDE对这个缺点进行了一些补救，使用成员变量或成员方法时，会在成员后标明是哪个上级
         Baby baby = new Baby();
         baby.showByBaby();
         baby.showByFather();
         baby.showByGrandFather();
     }
 }
 
 class GrandFather {
     public void showByGrandFather() {
         System.out.println("这是GrandFather的成员方法");
     }
 }
 
 class Father extends GrandFather {
     public void showByFather() {
         System.out.println("这是Father的成员方法");
     }
 }
 
 class Baby extends Father {
     public void showByBaby() {
         System.out.println("这是Baby的成员方法");
     }
 }

【原】Java学习笔记016 - 面向对象的更多相关文章

Java学习笔记之---面向对象
Java学习笔记之---面向对象 (一)封装 (1)封装的优点良好的封装能够减少耦合. 类内部的结构可以自由修改. 可以对成员变量进行更精确的控制. 隐藏信息,实现细节. (2)实现封装的步骤 1. ...
Java学习笔记之面向对象、static关键字
一周Java学习总结今天就总结理清一下关于面向对象和面向过程的程序设计的一些不同特点,以及讲下static关键字. 面向对象现在接触的Java是面向对象的,现在的程序开发几乎都是以面向对象为基础的 ...
Java 学习笔记(4)——面向对象
现在一般的语言都支持面向对象,而java更是将其做到很过分的地步,java是强制使用面向对象的写法,简单的写一个Hello Word都必须使用面向对象,这也是当初我很反感它的一点,当然现在也是很不喜欢 ...
【原】Java学习笔记019 - 面向对象
package cn.temptation; public class Sample01 { public static void main(String[] args) { // 仔细想一想,Ani ...
【原】Java学习笔记014 - 面向对象
package cn.temptation; public class Sample01 { public static void main(String[] args) { // 面向对象思想 // ...
【原】Java学习笔记020 - 面向对象
package cn.temptation; public class Sample01 { public static void main(String[] args) { // 成员方法的参数列表 ...
【原】Java学习笔记018 - 面向对象
package cn.temptation; public class Sample01 { public static void main(String[] args) { // 继承关系的子类可以 ...
【原】Java学习笔记017 - 面向对象
package cn.temptation; public class Sample01 { public static void main(String[] args) { // 继承关系中的pri ...
【原】Java学习笔记015 - 面向对象
package cn.temptation; public class Sample01 { public static void main(String[] args) { // 传递值类型参数 ...

随机推荐

php内核一些常识
整个PHP环境和Zend环境会涉及多个全局变量,下面是几个比较重要的: php_core_globals core_globals(main/php_globals.h) ==> PG PHP调 ...
Xamarin.Android 集成百度地图SDK
前言:趁着周六闲得没事干,赶紧搞一搞Xamarin,最近也是怪无聊的,枯燥的生活不如打几行代码带劲:好了我们进入正题我这篇文章时参考一位大佬的博客进行改变的,当然他写的需要一定的经验才可以看得懂,我 ...
最快的进程间通信方式你get了么
前言:天下武功为快不破!在信息爆炸.快速发展的新时代...,扯远了....进程间通信方式有很多,但最快的方式你知道么?由我娓娓道来... 一.共享内存方式主角闪亮登场了,噔噔瞪...,最快的方式就是 ...
js反爬-从入门到精通webdriver
学习JS反爬地址:http://openlaw.cn/login.jsp 想在指导案例中抓些内容,需要登陆账号密码发送会以下面方式发送所以需要找到_csrf和加密后的password,_csrf ...
GBDT 算法：原理篇
本文由云+社区发表 GBDT 是常用的机器学习算法之一,因其出色的特征自动组合能力和高效的运算大受欢迎. 这里简单介绍一下 GBDT 算法的原理,后续再写一个实战篇. 1.决策树的分类决策树分为两大 ...
Shell从入门到精通进阶之三:表达式与运算符
3.1 条件表达式表达式示例 [ expression ] [ 1 -eq 1 ] ` expression ` ` 1 -eq 1 ` test expression test 1 -eq 1 ...
.NET Core中Object Pool的简单使用
前言复用,是一个重要的话题,也是我们日常开发中经常遇到的,不可避免的问题. 举个最为简单,大家最为熟悉的例子,数据库连接池,就是复用数据库连接. 那么复用的意义在那里呢? 简单来说就是减少不必要的资 ...
批处理启动vm虚拟机服务 vm12启动无界面启动vm虚拟机系统 windows上如何操作服务 sc net启动关闭服务
windows(win10)批处理脚本打开vm虚拟机的服务,并且开启无界面虚拟机 @echo off net start "vds" net start "VMAuth ...
痞子衡嵌入式：ARM Cortex-M内核那些事（2）- 第一款微控制器
大家好,我是痞子衡,是正经搞技术的痞子.今天痞子衡给大家介绍的是第一款Cortex-M微控制器. 1.天生荣耀:ARM Cortex-M处理器由来 ARM公司自2004年推出ARMv7内核架构时,摒弃 ...
Markdown 语法详尽笔记大全 2019
目录 0.介绍 1.快捷键 2.基本语法 2.1 分级标题 # 写法1 # 写法2 上下文标题 2.2 字体设置斜体.粗体.删除线 _*~ 2.3 分割线 --- 或 *** 2.4 引 ...

【原】Java学习笔记016 - 面向对象

【原】Java学习笔记016 - 面向对象的更多相关文章

随机推荐

热门专题