Java基础 笔记（1）

JDK:java开发工具包

JRE:java运行时环境

JVM:java虚拟机

javac Demo01.java—>Demo01.class 字节码文件–>类加载器中–>运行java Demo01

标识符：字母 数字 _ $ 组成，其中数字不能开头，不能是关键字，可以是 中文

类名：首字母大写

变量名和方法名：驼峰命名法 myName showInfo（） addList（）

常量名：全部大写字母组成

包名：小写组成 域名倒置 com.baidu com.qianfeng

常量：final 数据类型 常量名 = 值； 值不可以改变。

变量：可以改变

数据类型 变量名 = 值；

数据类型：

基本数据类型：

整型：byte（1字节 -128~127 Byte） short（2字节 -32768~32767 Short） int（4字节 -2147483648~2147483647 Integer） long（8字节 0L Long）

浮点型：float（4字节 Float 0.0f） double（8字节 Double）

字符型：char（2字节 Character）

布尔型：boolean （true false Boolen）

引用数据类型:

类 class

数组 array

接口 interface

System.out.println(“int最大值:”+Integer.MAX_VALUE);

System.out.println(“int最大值:”+Integer.MIN_VALUE);

运算符：

1）算术运算符： + - * / % ++ –

int t = a++; (1)t = a (2) a = a+1

int j = ++a; (1) a= a+1 (2)j = a

2)赋值运算符： =   +=   -=   *=   /=  %= 

3) 比较运算符(结果为boolean类型)：  >   <  ==  <=  >=  !=

4）逻辑运算符: &&(逻辑与)  ||（逻辑或）  !（逻辑非）  &  |    ^异或
    a&&b（短路）:如果a为false，则结果为false。b将不被判断
    a&b:如果a为false，结果为false。b会进行判断。a与b都会执行。
    a||b（短路）:如果a为true，则结果为true。b将不被判断
    a|b:如果a为true，结果为true。b会进行判断。a与b都会执行。
    a^b:相同为false，不同为true。

5）条件运算符： 三目运算符  ？ ：
    条件表达式?语句1：语句2； //当表达式为true，结果为语句1，否则为语句2
6) 字符串连接符 +
7) 位运算符： &(按位与)  |（按位或）  ^（按位异或）   ~（按位取反）  >>（右移）  <<（左移）   >>>（无符号右移）
    byte b = 1 ; //0000 0001
    进制：二进制   十进制  八进制  十六进制
                符号
    二进制      0  1
    八进制      0-7    每三位成1位
    十进制      0-9    
    十六进制    0-9  a-f  每四位成一位

    进制转换：
        十进制---》二进制 : 除2取余  10--》1010
        二进制 --》十进制  ：位权 * 符号^(n-1)
            (1010)二---->（0*2^0+1*2^1+0*2^2+1*2^3） =10
        八进制---》二进制 
            1)通过十进制转换
            2) 773 八--> 111 111 011  二

Arrays 工具类的使用

常用方法：fill([] , value) sort([]) toString([]) …

方法重载(如果不能构成重载，编译出错)：在同一个类中，方法名相同，参数列表（个数、类型、顺序）不同，与返回值无关。

JVM内存一般分五个区域：

方法区 堆 栈 本地方法区 寄存器

方法区：存类的信息，常量池，静态方法区

栈（值类型）：存放调用方法的局部变量

存储在栈中的变量，作用域结束立即消失

堆（引用类型）：存数组或者引用对象

特点：

1 分配内存首地址

2 有默认值

3 gc（垃圾回收）

本地方法区：实现类库的调用

注意：在常量池中，java默认创建-128-127之间的常量对象
    对于字符串常量会首先去常量池查找，如果不存在就创建字符串常量

值类型和引用类型参数的区别：两个数的互换
如果参数为值类型：传递的是值的副本，形参不能改变实参的值
如果参数类型为引用类型：传递的是地址，形参可以改变实参的值

/*

字符串常量对象：保存在字符串常量池中

总结：字符串保存在常量池中（不管是之前存在的还是通过 String str = new String(“string”)新创建的）

*/

public static void main(String[] args)

{

String str = “你好”;

String str1 = “你好”;

System.out.println(str==str1); //结果为true

show(str);//将str变量的内容“你好”传递给方法
    System.out.println(str);  //你好

//下面这条语句创建了几个对象？此时只会创建一个对象，因为”你好“已经在常量池中存在
    String str3 = new String("你好");
    String str4 = str3;
    str3 = "hi";  //“hi”字符串在常量池不存在，则会在常量池中创建一个对象，str3就指向该对象
    System.out.println(str4); //你好
}

static  void  show(String str){
    str = "hello";  //方法中重新赋值
}

System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

src:源数组

srcPos:从源数组的那个下标开始拷贝

dest：目标数组

destPos:目标数组的复制的位置

length：复制的数组元素的长度

局部变量和全局变量（成员变量）的区别：

局部变量：随着方法入栈而初始化，方法出栈而消失

没有默认值，必须声明后赋值

保存在栈中

作用域为声明的位置到它所在的结构结束

成员变量：随着初始化对象而创建，会随着对象的回收而消失
        有默认值的
        保存在堆中
        作用域在整个类中
注意：当局部变量和成员变量重名时，局部变量会覆盖全局变量

class Person

{

//成员变量：全局变量

String name;

int age;

public void say(){

int a = 10; //局部变量

int age = 60; //重名，局部变量覆盖全局变量

System.out.println(“age=”+age+”,a=”+a);

}

}

封装：封装内部细节，让属性私有，通过非私有的方法去访问。

读：

数据类型 getXXX（）

写：

void setXXX(数据类型 参数)

访问修饰符：

private:私有的，只有当前类的内部可以访问

[default]：默认的，可以在同一个包中访问

protected：受保护的，可以在同一个包中或者不同包的子类中可以访问

public：公有的，所有类均可以访问

this:当前对象。当出现局部变量和成员变量重名时需要通过this来访问成员变量

static关键字：

1 静态成员变量：

特点：

1） 和类同时加载，会在方法区开辟空间，初始化数据

2） 通过类名访问。 类名.静态成员变量

3） 通常用于存储所有类的共享数据

2 静态成员方法：
特点：
1）静态方法中只能访问静态成员（不能使用this）
2）非静态方法中可以访问静态成员也可以访问非静态成员

静态成员变量和非静态成员变量区别：
1）生命周期
    静态成员变量随着类的加载而加载，在方法区初始化，在程序结束即消失
    非静态成员变量随着对象的初始化，在堆中创建，在对象被垃圾回收时而消失

2）存储
    静态成员变量通常保存对象共享的数据
    非静态成员变量是保存某一个对象的数据

3）访问方式
    静态成员变量通过类名直接访问，也可以通过对象访问
    非静态成员变量只能通过对象访问

构造代码块：优先于构造方法执行，主要用于初始化成员变量

每次创建对象都会执行

静态代码块：static{}，用来初始化静态成员变量。随着类的加载而执行，只 执行一次;//静态代码块中不能直接引用非静态成员

注意：在程序优化中，不建议过多的使用static，因为它会长时间保留在内存 中

{

//普通代码块：作用域

int i= 6;

System.out.println(“i–>”+i);

}//i作用域消失

对象初始化过程：

1 加载类的字节码文件到jvm的方法区中

2 为静态变量在静态区开辟内存空间，赋初始值

3 加载静态代码块，初始化静态成员变量

4 开辟堆中空间（成员变量），给成员变量初始化

5 加载构造代码块

6 加载构造方法

7 将堆空间的首地址赋值给栈中对象的引用

设计模式：单例

解决问题：一个类在内存中只有一个对象

1 构造方法私有化

2 构造方法私有化后，就一个对象都不能创建了，只能有该类自身提供对象

饿汉式：在声明类引用时实例化对象

懒汉式：在获取类的方法中先判断该对象是否为空，如果为空就实例化

3 提供让外界能够获得该对象的方法

懒汉式（线程不安全的）
饿汉式（线程安全的）

//饿汉式

class Single

{

//构造方法私有化：不能在本类的外部通过new创建对象
    private Single(){

    }
    //定义一个本类的对象
    private static Single single = new Single();

    //向外界提供可访问的方法，返回当前类的对象
    public static Single getInstance(){
        return single;
    }

}

//懒汉式

class Single2

{

private Single2(){}

private static Single2 single ;

public static Single2 getInstance(){
    if(single == null)
        single  = new Single2();
    return single;
}

}

当创建子类对象时，会首先调用父类无参的构造方法，然后调用子类相应的构造方法

当子类通过super（）显示调用父类有参构造方法后，创建子类对象时，将 不会调用父类无参的构造方法

super：父类对象

子类对象初始化过程：

1 父类静态代码块

2 子类静态代码块

3 父类构造代码块

4 父类构造方法

5 子类构造代码块

6 子类构造方法

class Parent

{

private String name;

public int age;

static{

System.out.println(“父类的静态代码块”);

}

{

System.out.println(“父类的构造代码块”);

}

Parent(){

System.out.println(“父类的构造方法”);

}

public void say(){

System.out.println(“父类age:”+age);

}

}

class Child extends Parent

{

private int age;

static{

System.out.println(“子类静态代码块”);

}

{

System.out.println(“子类构造代码块”);

}

Child(){

System.out.println(“子类构造方法”);

}

public void sayHi(){

super.age = 100;

this.age = 50;

System.out.println(“子类age:”+age);

say();

}

}

this和super：
this：代表当前对象。this.成员。
       this（）本类的构造方法，必须在第一行
super：代表父类对象，并不是一个引用，没有父类的指向（因此super不能作为参数传递）
        可以通过super.父类成员来访问父类的成员
        也可以通过super（）调用父类的构造方法，必须在第一行

this（）和super（）不能同时出现
this和super关键字不能出现在静态方法中

子类 对象名 = new 子类（）；

对象可以调用的方法有:

父类继承的方法

子类重写父类的方法

子类新增的方法

父类 对象名 = new 子类（）；

对象可以调用的方法有:

父类继承的方法

子类重写父类的方法

重写（覆盖）：前提条件 必须继承

注意：

1 父类的私有方法不能被重写

2 子类重写父类的方法时，重写的方法权限必须大于等于父类中的方法权限

3 静态只能静态覆盖–>父类的静态方法不能重写

父类：public static void gg(){}

子类中不能重写gg()这个方法，可以定义自己的gg()方法

4 当父类中的方法有返回类型时，子类重写父类方法时，返回类型可以是父类类型也可以是父类的子类类型