每日一题总结 2020.01.14-2020.01.24

• 面向对象设计方法的主要特征：抽象，封装，继承，多态。

public class Test
{
    static int i;

    public static void main(String[] args) {
        System.out.println(i);
    }

       输出结果是：0。
       静态变量会被默认初始化，
       在类中，没有"static"，就会显示”Error:(6, 28) java: 无法从        静态上下文中引用非静态 变量 i“
       在方法中，变量也是要初始化的。
       否则就会显示”Error:(6, 24) java: 可能尚未初始化变量i“。

总结：只有在类中static变量可以不初始化，在类中非static变量和方法中的变量都需要初始化。

 public static void main(String[] args) {
      System.out.println(100%3);
      System.out.println(100%3.0);
    }

运行结果为：1和1.0
（运算结果的精确度取决于%右边的。）

• Java基本类型中，带小数的默认是double类型。

public static void main(String[] args) {
      System.out.println(Math.round(11.5));
      System.out.println(Math.round(-11.5));
    }

运行结果为：
12和-11。
(将括号内的数+0.5之后，向下取值.
比如：
round(3.4)就是3.4+0.5=3.9，向下取值是3，所以round(3.4)=3;
round(-10.5)就是-10.5+0.5=-10，向下取值就是-10，所以round(-10.5)=-10

所以，Math.round(11.5)=12;

所以，Math.round(-11.5)=-11;)

• 编译器可以将字符串“共享”，String是不可变类，String类没有提供用于修改字符串的方法。字符串都是常量，例如“ABC”会被存储在常量池中。对字符串进行任何更改操作都会产生新的String对象。如字符串string=”HELLO”永远只包含HELLO这几个字母，而不能修改其中任何一个字符。当然可以修改字符串变量string的引用，让它引用另一个字符串。
         而StringBuilder与StringBuffer是可变类，它们的字符串对象可以更改，对可变字符串的操作不会生成新的对象，即对同一个字符串对象操作。

public static boolean isAdmin(String userID)
    {return userID.toLowerCase()=="admin";}
    public static void main(String[] args) {
  System.out.println(isAdmin("Admin"));
System.out.println("Admin".toLowerCase());
 System.out.println("admin"=="admin");}

运行结果为：
false
admin
true

       String类对象为不可变字符串，是字符串常量可共享。subStrng、+、toLowerCase( 如上所示 )等操作产生的结果不能共享。
       比较字符串值是否相等时使用equals()方法，不能使用"==" "=="比较的是字符串的地址是否相同。如果字符串在常量池中，可以使用==比较，因为指向的都是同一个字符串。
再比如：String greet1="Hello"; System.out.println(greet1.substring(0,3)=="Hel"
运行结果为:false
（ 1 ）String str1=”first”;
       JVM在运行时先查找常量池中是否有该字符串，如果有则直接返回该字符串的引用给“ first ”(实现了字符串的共享) ；否则先在常量
池中创建该字符串并返回引用。
        此时只会在常量池中创建String对象，不会在堆中创建。
（2）String str2=new String(“second”);
       该代码生成了两个String对象。因为使用了“ ”会现在常量池中查找是否存在second对象，没有则创建。 否则不创建；在常量池创建完成后，由于使用了new，JVM会在堆中创建内容相同的String对象，并将引用 返回给str2.。
（3）String str3=”what”; String str4=str3+”a nice day”;
       运行时，+ 相当于new，所以堆中会有“what a nice day”对象；常量池中会有”what” “a nice day”两个对象，而不会有”what a nice day”对象。

public static void main(String[] args) {
        String greet1="Hello";
        String greet2="Hello";
        System.out.println(greet1==greet2);
        System.out.println(greet1=="Hello");
        String string1=new String("Hello");
        String string2=new String("Hello");
        System.out.println(string1==string2);
   StringBuilder stringBuilder=new StringBuilder("Hello");
   StringBuilder stringBuilder2=new StringBuilder("Hello");
       System.out.println(stringBuilder==stringBuilder2);
}

运行结果为:
true
true (体现字符串常量共享)
false
false

• String、StringBuilder、StringBuffer的区别：
         String 是不可变类，也就是说，String 对象一旦被创建，其值不能被改变；而StringBuffer是可变类，当对象创建后可以对值进行修改。
         实例化 String 时，可以用构造函数 new String… ，也可以用 “…” 赋值。而StringBuffer 只能用构造函数。
         StringBuffer 是线程安全的，它的所有方法几乎都用 synchronized 修饰，而 StringBuilder 是非线程安全的，但效率相对较高。

• 可以用null调用静态方法：

public class A20200118 {

   public static void hello() {
        System.out.println("Hello");
   }

    public static void main(String[] args) {
        A20200118 a = null;
        a.hello();
    }
}

运行结果为:
Hello
在IDEA的console中输入javac 路径(… .java)，

可以看到输出的.class文件如下所示：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

public class A20200118 {
    public A20200118() {
    }

    public static boolean isAdmin(String var0) {
        return var0.toLowerCase() == "admin";
    }

    public static void hello() {
        System.out.println("Hello");
    }

    public static void main(String[] var0) {
        Object var1 = null;
        hello();
    }
}

尽管是null,它也是调用了类的静态方法的。
再写个非静态方法，由实例调用:

public class A20200118 {
    public void hello() {
        System.out.println("Hello");
    }

    public static void main(String[] args) {
        A20200118 a =new A20200118();
        a.hello();
    }
}

这时的class文件变成：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

public class A20200118 {
    public A20200118() {
    }

    public static boolean isAdmin(String var0) {
        return var0.toLowerCase() == "admin";
    }

    public void hello() {
        System.out.println("Hello");
    }

    public static void main(String[] var0) {
        A20200118 var1 = new A20200118();
        var1.hello();
    }
}

它确实是用实例去调用非静态方法的。
**

• this()和super()不可以同时出现在一个构造函数中。
         “ 调用构造器的语句 ( this /super )只能作为另一个构造器的第一条语句出现 ” ,注定了只能调用一个构造函数。默认的父类的无参构造或者本类的其它构造，自己选一个。
          Java规定，在执行构造函数之前必须执行父类的构造函数，直到这个类是java.lang.Object类的构造函数。
         然而函数的入口是子类构造函数，因此任何构造函数第一句必须是执行父类构造函数，如果没有添加super关键字，那么编译器会为该构造函数第一句添加一个super()语句(可以这么理解，当然编译以后并不是这样)。如果有super关键字显示的调用父类构造函数，就是用指定的那个父类构造函数，否则使用默认的无参数构造函数。也有一种情况例外，就是存在this关键字，调用本类其它构造函数，但是按照递归调用，最终还是会调用父类构造函数。
         如果继承的父类没有无参数构造函数，那么这个类第一句必须显示的调用super关键字来调用父类对应的有参数构造函数，否则不能通过编译。

• this()和super()都是指向对象的，不能在static环境中使用。

• 局部变量不能有修饰符。 （比如static ）
  因为局部变量本身就是一个访问权限的设定，只能在局部调用，生命周期就是 { }。

• 面向对象开发中，引用传递意味着传递的并不是实际的对象，而是对象的引用，因此外部对引用对象所作的改变会反映到所引用的对象上。

• 黑盒测试方法不关心程序内部的逻辑，只是根据程序的功能说明来设计测试用例。
  黑盒测试方法分为：
  等价类划分法、边界值测试法、错误推测法。
  而语句覆盖、逻辑覆盖、路径覆盖都属于白盒测试。

• 关于Socket通信：
  客户端通过socket()方法创建socket对象。
  服务端通过**serverSocket()**方法创建TCP连接对象，通过accept()方法接受客户端请求。

尚未解决的：

方法通常存储在进程的哪一区？
答:方法区。