java笔记

一切都是对象（2017.7.26）

学习笔记

a.JAVA对象在内存中存储的位置：寄存器，堆栈，堆，常量存储，非ram区。

1，寄存器

这是最快的存储区，在处理器内部，无法手动操纵这一块内存，大小数量比较有限

2，堆栈

仅此于寄存器存储速度的存储区，位于RAM（随机存储区）中，通过堆栈指针直接操纵分配内存，指针下移，分配新的内存，指针上移，释放内存。创建程序时，java系统必须知道存储在堆栈内所有项的生命周期，以便上下移动指针，灵活性较差。JAVA对象的引用存储在堆栈中，但是JAVA对象不存在于堆栈空间中。

3，栈

一种通用的内存池，也存在与RAM中，但是编译器不需要知道存储在栈空间的对象的生命周期，所以灵活性较强，，当需要一个对象时，只需要new一个对象，这个对象就会存在与栈空间中。

4，常量存储

常亮通常存储在程序代码内部，这样的量是很安全的，并不会被改变，一般称为字符串常量池，放在ROM中

5，非RAM存储区

不依赖于程序存在的数据存在于两个地方，一种是流对象，一种是持久化对象。流对象存在于计算机和计算机传输中的字节流中。持久化对象存在于ROM中（计算机硬盘，磁盘），JAVA提供了JDBC和HIBERNATE两种轻量级操作数据库的方式，讲持久化对象恢复，成为反序列化。

b.基本数据类型的大小

基本数据类型有八种，各有各的取值范围

定义一个基本数据类型

int a = 10；

则在内存堆栈区域开辟了4个字节的大小给a这个非引用的自动变量，直接存储值，并不是地址。

如果使用包装类型new一个对象，那就是非基本对象，存在于堆空间中，而不是堆栈空间

对于这8种基本数据类型的变量，变量直接存储的是“值”，因此在用关系操作符==来进行比较时，比较的就是 “值” 本身。要注意浮点型和整型都是有符号类型的，而char是无符号类型的（char类型取值范围为0~2^16-1).

高精度计算的类，BigInteger和BigDecimal，两种类都是包装器类，但是没有对应的基本类型。都是存在于堆空间。

总结来说：

　　1）对于==，如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；

　　　　如果作用于引用类型的变量，则比较的是所指向的对象的地址

　　2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量

　　　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

　　　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

一切都是对象(2017.7.27)

a.成员变量个成员方法

定义在类内部的属于类的成员变量，java会自动为其赋值初始值。但是如果不是成员变量的定义一个基本数据类型的参数，那么java不会为其赋值，如果程序员在定义一个基本数据类型变量时并没有对其赋值，那么java在运行时会报错，而不是像C++一样只是警告

a(1).方法名和参数列表（方法签名）才是定义一个方法的唯一标识，方法重载可以是参数不能，参数个数不同，参数类型不同，参数类型和参数个数都不同，也可以是方法名不同,给对象发送消息，就是让一个对象去调用某个方法

a(2).String类支持“+”和“+=”，来获得一个新的值.

class Tank {
int a;
}


public class TIJTest1 {
public static void main(String[] args) {
Tank t1 = new Tank();
Tank t2 = new Tank();

t1.a = 10;
t2.a = 15;

System.out.println("ti.a : "+t1.a+" ,t2.a : "+t2.a);

//此时是对象的引用的赋值，把t2指向的地址赋值给t1，所以t2的地址就覆盖了t1的地址，所以t1,t2就指向了同一个地址
// t1=t2;
//
// System.out.println("ti.a : "+t1.a+" ,t2.a : "+t2.a);
//
//此时改变了t1的值，因为t1,t2指向的是同一个地址，也就是同一个引用，所以改变t1地址中的值，t2也指向那个地址，所有，t2所对应的值也改变了
// t1.a = 18;
//
// System.out.println("ti.a : "+t1.a+" ,t2.a : "+t2.a);
//
//因为只是把t2.a的值传递给t1.a，所以只是值的传递，不会影响t1,t2的地址，或者说是引用
t1.a = t2.a;

System.out.println("ti.a : "+t1.a+" ,t2.a : "+t2.a);


t1.a = 18;

System.out.println("ti.a : "+t1.a+" ,t2.a : "+t2.a);
}

}

一切都是对象(2017.7.28)

a.==和equals的区别

==是所有对象和基本操作数据类型都有的运算比较符，比较的是两个引用之间的关系，更确切的说是比较两个对象的地址是否相同。而equals是比较两个对象的值是否相等，对于基本数据类型，equal是不存在的，基本数据类型，只能使用==和！=来计较两个基本数据类型的值是否相等。

equals方法默认是比较两个地址是否相同，但是很多类都重写了equals方法，所以一般是比较两个类的的值是否相等，大多数JAVA类库都实现了equals方法，以便来比较对象的内容，而不是比较对象的引用。

b.

c.操作符

1.算数操作符

+-*/%

2.关系操作符，返回boolean

> < >= <= == !=

3.逻辑操作符

&& || ！ 逻辑运算符只能连接关系操作符的boolean 也就是 boolean 逻辑运算符 boolean （bool && bool） 这样才能输出一个bool类型的常亮

4.

5.cast类型转换

6.

向上转型

7777 

8.for循环内的逗号操作符，第一个分号里面能定义多个同类型的变量，并且以逗号分开

一切都是对象(2017.8.3)

a.方法重载

方法重载只能靠两个地方来辨别是否是重载函数，第一，参数类型，第二，参数的多少。最好不要使用网上所说的改变方法返回值来充当方法重载，因为当你明确一个方法返回值的时候，比如int c = f(); 这样可以调用成功，但是，如果一个方法存在没有返回值和有返回值两个重载的类型的话，你可能会直接调用 f();  这样JAVA虚拟机并不知道你是否想返回一个类型，所以java中不能使用返回值类型不同的方法来定义两个方法重载函数。

b.类型参数提升

package test.collection.set;


class testOverLoading {
void f1(char x) { System.out.print("f1(char)"); }
void f1(byte x) { System.out.print("f1(byte)"); }
void f1(short x) { System.out.print("f1(short)"); }
void f1(int x) { System.out.print("f1(int)"); }
void f1(long x) { System.out.print("f1(long)"); }
void f1(float x) { System.out.print("f1(float)"); }
void f1(double x) { System.out.print("f1(double)"); }

void f2(byte x) { System.out.print("f2(char)"); }
void f2(short x) { System.out.print("f2(short)"); }
void f2(int x) { System.out.print("f2(int)"); }
void f2(long x) { System.out.print("f2(long)"); }
void f2(float x) { System.out.print("f2(float)"); }
void f2(double x) { System.out.print("f2(double)"); }

void f3(short x) { System.out.print("f3(short)"); }
void f3(int x) { System.out.print("f3(int)"); }
void f3(long x) { System.out.print("f3(long)"); }
void f3(float x) { System.out.print("f3(float)"); }
void f3(double x) { System.out.print("f3(double)"); }

void f4(int x) { System.out.print("f4(int)"); }
void f4(long x) { System.out.print("f4(long)"); }
void f4(float x) { System.out.print("f4(float)"); }
void f4(double x) { System.out.print("f4(double)"); }

void f5(long x) { System.out.print("f5(long)"); }
void f5(float x) { System.out.print("f5(float)"); }
void f5(double x) { System.out.print("f5(double)"); }

void f6(float x) { System.out.print("f6(float)"); }
void f6(double x) { System.out.print("f6(double)"); }

void f7(double x) { System.out.print("f7(double)"); }

void testConstVal() {
System.out.print("5 : ");
f1(5);f2(5);f3(5);f4(5);f5(5);f6(5);f7(5);System.out.println();
}

void testChar() {
char x = 'x';
System.out.print("char : ");
f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
}
void testByte() {
byte x = 0;
System.out.print("byte : ");
f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
}
void testShort() {
short x = 0;
System.out.print("short : ");
f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
}
void testInt() {
int x = 0;
System.out.print("int : ");
f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
}
void testFloat() {
float x = 0f;
System.out.print("float : ");
f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
}
void testLong() {
long x = 0L;
System.out.print("long : ");
f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
}
void testDouble() {
double x = 0;
System.out.print("double : ");
f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);System.out.println();
}
}




public class TIJTest13 {
public static void main(String[] args) {
testOverLoading t = new testOverLoading();
//t.testConstVal();
//t.testChar();
//t.testByte();
//t.testShort();
//t.testInt();
//t.testFloat();
//t.testLong();
t.testDouble();
}
 
 }
 c.构造函数

创建一个类后，系统会默认给你一个无参的构造函数，如果没有构造函数，你讲无法创建实例对象。如果你手动创建一个无参或者有参的构造，那么编译器就不会再帮你创建。