Java基础篇之基础知识（一）

1.Java8种基本数据类型：

byte（8）char(16) short(16) int(32) float(32) double(64) long(64) boolean

2.包装类型：

Java基本类型不具有对象特性，每一种Java基础类型都对应一种Java包装类型

并且在Java5之后出现了自动装箱和拆箱；

装箱：基础类型转换为包装类型

拆箱：包装类型转换为基础类型

int a = 1;
//手动装箱
Integer a1 = new Integer(a);
//自动装箱Integer a2 = a;
//手动拆箱int a3 = a1.intValue();
//自动拆箱int a4 = a1;

​

3,String类

• 字符串工具类StringUntils

1. public static boolean isEmpty(String str)

public static boolean isEmpty(String str)
StringUtils.isEmpty(null) = true
StringUtils.isEmpty("") = true 
StringUtils.isEmpty(" ") = false //注意在 StringUtils 中空格作非空处理

2.public static boolean isNotEmpty(String str)

判断某字符串是否非空，等于 !isEmpty(String str)

3.public static boolean isBlank(String str)

判断某字符串是否为空或长度为0或由空白符(whitespace) 构成

StringUtils.isBlank(null) = true
StringUtils.isBlank("") = true
StringUtils.isBlank(" ") = true

4.public static String trim(String str)

去掉字符串两端的控制符(control characters, char <= 32) , 如果输入为 null 则返回null

StringUtils.trim(null) = null
StringUtils.trim("") = ""
StringUtils.trim(" ") = ""
StringUtils.trim(" \\b \\t \\n \\f \\r    ") = ""
StringUtils.trim("     \\n\\tss   \\b") = "ss"
StringUtils.trim(" d   d dd     ") = "d   d dd"
StringUtils.trim("dd     ") = "dd"
StringUtils.trim("     dd       ") = "dd"

• String类被final修饰，一旦创建String对象,那么它的值就无法改变

concat（）方法只是生成一个新对象，然后将值放到新对象

concat（）源码：

public String concat(String str) {        
    int otherLen = str.length();        
    if (otherLen == 0) {            
        return this;        
    }        
    int len = value.length;        
    char buf[] = Arrays.copyOf(value, len + otherLen);        
    str.getChars(buf, len);        
    return new String(buf, true);    
}

concat（）测试：

String s = "22";       
System.out.println(s);//22       
String b = s.concat("333");        
System.out.println(s);//22        
System.out.println(b);//2233

无法改变的优点:

1. 自然线程安全

2. 可以共用不会改变值

3. 哈希值：例如hashcode，hashset用string作为索引，不可变可保证哈希码不变，这意味着，无需每次都使用哈希码。这样更有效

4. string pool：相同字符串共用一个引用，字符串变化会导致其他引用出现错误！

5. 安全：字符串被广泛用许多Java类的参数，例如网络连接，打开文件，如果字符串不是不可变的，则连接或文件将会改变这可能会导致严重的安全问题。

• String,StringBuffer,StringBuilder

String——可变，线程安全==字符串不打算更改使用

StringBuffer——可变，非线程安全==字符串更改单线程访问

StringBuilder——可变，线程安全（synchronized进行同步）==字符串可以更改，并多线程访问

• 怎么理解 String s = new String("aaa")？

首先：在字符串常量池中还没有 “aaa”对象时，这行代码最终会创建两个String对象

分解：s只是一个String变量 用来承接引用值；new String ; "aaa"

字符串字面量“aaa”，在编译时候如果字符串常量池中不存在“aaa”则会在字符串常量池创建这个对象并把引用赋值给s，但是 new String() 执行时会堆中创建一个新对象。

字符串常量池：是一用来保存字符串对象的容器。

字符串字面量：就是两个引号之间的字符序列例如：“aaa”。

4.Java存在的关键字：

5.Java命名规范：

1、 项目名全部小写

2、 包名全部小写

3、 类名首字母大写，如果类名由多个单词组成，每个单词的首字母都要大写。

如：public class MyFirstClass{}

4、 变量名、方法名首字母小写，如果名称由多个单词组成，每个单词的首字母都要大写。

如：int index=0;

public void toString(){}

5、 常量名全部大写

如：public static final String GAME_COLOR=”RED”;

6、所有命名规则必须遵循以下规则：

1. 名称只能由字母、数字、下划线、$符号组成不能以数字开头

2. 名称不能使用JAVA中的关键字。

3. 坚决不允许出现中文及拼音命名。

6.运算符：

除了（+ - * /）还有（&与：一真就为真），（| 或：一假就为假 ），（！非）这也称为位运算符；

另外（&&和||分别也是代表或和与的逻辑关系只不过还另外带有短路效果）

三元运算符：？—> 例如：int s = a>b?a:b; 意思是如果a>b成立，那么s = a 否则 s = b；

7.形参与实参的简单理解

add(1,2)//调用者其中1,2就为实参
public int add (int a , int b){}//被调用者其中a,b就为形参，作用是为了接受实参的值进入方法运行

8.Java中参数传递

Java中参数传递是将值的地址传给形参

public class Empolyee {    
    private  String name;    
    private  Integer salary;    
    private  Integer age;    
    public String getName() {        
        return name;    
    }    
    public Integer getSalary() {        
        return salary;    }    
    public Integer getAge() {        
        return age;    
    }    
    public void setName(String name) {        
        this.name = name;    
    }    
    public void setSalary(Integer salary) {        
        this.salary = salary;    
    }    
    public void setAge(Integer age) {        
        this.age = age;    
    }    
    public String getAddress() {        
        return super.toString();    
    }
}

public class Test {    
public static void main(String[] args) {  
// write your code here        
    Test test = new Test();        
    Empolyee empolyee = new Empolyee();        
    empolyee.setName("aaa");        
    System.out.println("最初的地址"+empolyee.getAddress()+"名字："+empolyee.getName());//@677327b6名字：aaa        
    test.change(empolyee);//        
    System.out.println("执行未生成新对象只改变属性值方法后的地址："+empolyee.getAddress()+"名字："+empolyee.getName());//@677327b6名字：bbb        
    test.change2(empolyee);//@14ae5a5名字：ccc        System.out.println("执行生成新对象并改变属性值方法后的地址："+empolyee.getAddress()+"名字："+empolyee.getName());//@677327b6名字：bbb        
    Empolyee empolyee1 = test.change2(empolyee);//@7f31245a名字：ccc        
    System.out.println("执行生成新对象并改变属性值方法后的地址："+empolyee1.getAddress()+"名字："+empolyee1.getName());//@7f31245a名字：ccc    
}    
private void change(Empolyee empolyee){        
    empolyee.setName("bbb");    
}    
private Empolyee change2(Empolyee empolyee){        
    empolyee = new Empolyee();        
    empolyee.setName("ccc");        
    System.out.println("执行生成新对象并改属性值方法中的地址："+empolyee.getAddress()+"名字："+empolyee.getName());        
    return empoly​
}

​此次记录也是自己学习记录的过程，笔者能力有限如果您发现有不足或者错误之处，敬请雅正，不舍赐教。

如果你也在学习或者复习，可以关注我的公众号【Java成长录】，有系统的学习规划路线，每次学习记录文章。

参考文献：

Eckel B. Java 编程思想[M]. 机械工业出版社, 2002