共计 4699 个字符，预计需要花费 12 分钟才能阅读完成。
一、java” 一次编译, 到处运行 ” 的跨平台性：
跨平台的原因：同样的一个 java 字节码文件(.class), 既可以在 java CPU 上运行, 也可以通过 Windows 的
java 字节码解释程序,(就像一个虚拟的 java CPU, 也就是 JVM(java 虚拟机)), 进行解释运行
只要操作系统上有相应的 java 字节码解释程序,.class 文件就能在这个操作系统上编译运行,
不是所有的操作系统都有字节码解释程序!
二、堆和栈内存？
- java 将内存划分为堆内存和栈内存，定义的变量是存放在栈内存中的，而 new 出来的对象和数组是存放在堆中的
- 栈内存：当一个函数调用时, 会在栈内存中申请一个空间, 当函数中定义一个变量时, 会分配到这个函数申请的栈空间中
，函数运行结束时, 函数的栈空间被收回, 在这个函数中定义的变量也随之被收回
- 堆内存：用 new 关键字产生的数组和对象都存放在堆内存中，由 java 的垃圾回收器来自动管理, 堆中产生一个数组或对象,
，还可以在栈中定义一个 ” 引用变量 ”, 取值等于堆中的数组或对象的首地址, 以后就可以直接通过栈中的引用变量
，直接调用在堆中的数组或对象, 栈中的这个变量就是堆中对象或数组的别称，或者是代号
- 引用变量是一个普通变量, 第一次在栈中分配, 当超过他的作用域之外就会被回收, 而堆中的对象或数组, 即使不使用, 方法结束
也不会释放, 只是没有引用变量指向他的首地址了, 变成垃圾, 不能使用, 但是依然站着堆内存空间不放, 到最后被垃圾回收器回收走 这就是 java 比较消耗内存的原因
public class Arraylist_demo {public static void main(String[] args) {
// 定义了一个普通变量, 其中要装的数据是堆中某个对象的首地址
int[] x;
// 在堆内存中产生了一个数组, 将首地址赋值给 x
x = new int[5];
int sum = 0;
for (int i = 0; i < x.length; i++) {x[i] = i + 1;
sum += x[i];
}
// x 变量中的值设为 null,x 就与原先的数组对象断开了关系，原来的数组对象就没有任何引用变量指向它, 然后他就等待垃圾回收器来将它释放
x = null;
System.out.println(sum);
// 静态数组, 定义时就赋值
// ! int[5], 不能指定长度 !
int[] arr = new int[] {1, 2, 3, 4, 5};
// arr = null;
// java.lang.NullPointerException 空指针异常：// 使用时如一个函数返回一个对象, 使用时判空, 不让经常导致空指针异常
for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);
}
// java.lang.ArrayIndexOutOfBoundsException 数组下标越界
// System.out.println(arr[5]); 角标大于最大角标
// 防止异常使用 length
System.out.println("最后一个数为：" + arr[arr.length - 1]);
/**
* 多维数组：*
* 类似棋盘
*/
int[][] xx = new int[2][3];
xx[0][0] = 5;
xx[1][2] = 8;
for (int i = 0; i < xx.length; i++) {for (int j = 0; j < xx[i].length; j++) {System.out.println("xx[" + i + "][" + j + "]" + xx[i][j]);
}
}
System.out.println("-----------------------------------------------------------");
/**
* arraycopy
*/
int[] aa = new int[] {2, 3, 1, 5, 9};
int[] bb = new int[10];
System.arraycopy(aa, 0, bb, 2, aa.length);
for (int i = 0; i < bb.length; i++) {System.out.println("bb[" + i + "]：" + bb[i]);
}
}
}三、java 和 Android 的区别：
java 内涵:
1、一种编程语言
2、一套开发工具
3、一个运行环境
Android 是：具体的操作系统，可以用 java 语言来编写
四、面向对象
java 中的对象：万物皆对象，指的是现实中存在的具体实例；·面向过程：[主 '谓' 宾]重点在谓语, 怎么操作？·面向对象
['主' 谓宾]重点是主语, 操作谁？·三大特征
封装 继承 多态
·核心
类与对象
{类：是对一种事物的描述，是抽象的，概念上的定义 - 动物 ***
{对象：是实际存在的某个该类事务的个体，也称为实例 - 猫，狗
private 私有的 public 公开的
四.1：类
一个类就是一个小的模块，尽可能的只公开必须让外部知道的内容，隐藏其他一切内容
设计时避免一个类直接修改另一个类的数据
模块设计：强内聚：许多功能尽量在类的内部独立完成，不让外面干预
弱耦合：给外部尽可能少的方法调用
四.2：this 关键字
- 一个类中的成员方法可以直接调用同类中的其他成员
- 让该类的成员变量名和对其赋值的成员方法的形参变量同名
四.3：垃圾回收
System.gc(); - 叫来垃圾回收器
五、static
静态对象被所有的实例对象所共享
属性作用域
方法中可以访问属性，但方法之间不能访问彼此内部定义的变量
- 静态方法
使用前不用创建任何对象
main 方法是静态的，JVM 在执行 main 方法时不创建 main 方法所在的类的实例对象，所以不能直接访问该类的非静态成员，必须创建该类的一个实例对象，才能通过这个对象去调用非静态成员
- 静态变量
特定的数据在内存中只有一份，无论是否产生，或产生了多少对象；
- 静态代码块：
一个类可以中可以使用不包含在任何方法中的静态代码块，类被载入时，静态代码块执行，且执行一次，常作属性初始化操作。
即使产生多个实例对象，其中静态代码块只执行一次
当一个程序中用到了其他的类，类是在第一次被使用的时候才被装载，而不是在程序启动时就加载程序中的所有用到的类
- 子类对象实例化：
new关键字
六、多线程
六.1：进程
在多任务的系统中，每个独立执行的程序都被称为进程(正在进行的程序)
CPU 只有一个的情况下，每个进程之间要不断的切换，反而要额外的开销 (交替执行多个程序) 反而更慢
双 CPU 系统才能实现多进程，每个 CPU 一个执行一个程序，两个程序同时进行
一个进程可以包含一个或多个线程
六.2：线程
一个线程就是一个程序内部的一条执行线索
多线程：一个程序实现多段代码同时交替运行，就需要产生多个线程，并且指定每个线程要执行的代码
Thread.currentThread().getName();
Thread thread = new Thread();
// 后台线程
thread.setDaemon(true);- 多线程卖票案例
public class ThreadDemo {public static void main(String[] args) {
try {
/**
* 一个 thread 对象是一个线程
*/
TestThread tt = new TestThread();
// 继承 thread
// tt.start();
// tt.start();
// tt.start();
// tt.start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();} catch (Exception e) {// TODO: handle exception}
}
}
/**
* 实现 runnable 接口比继承 thread 灵活
*
* 适合多个相同程序代码的线程去处理同一资源的情况，把虚拟 CPU(线程)同程序代码、数据有效分离，体现了面向对象的设计思想
*
* @author TianYu
*
*/
class TestThread implements Runnable /* extends Thread */ {
int tickets = 100;
@Override
public void run() {while (true) {if (tickets > 0) {System.out.println(Thread.currentThread().getName() + "is show" + tickets--);
}
}
}
}基础
① if & switch
/**
* 使用 {} 使得代码可读性好
*
* @author TianYu
*
*/
public class If_demo {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);
System.out.println("输入数字");
int i = scanner.nextInt();
/**
* if 语句 执行多条语句要放在 {} 中的代码块中
*
* 每个语句可以是使用 {} 组成的复合语句
*/
if (i < 3) {System.out.println("输入的数字 <3");
} else if (i >= 3 && i <= 8) {System.out.println("输入的数字在 3 和 8 之间");
} else {System.out.println("输入的数字 >8");
}
/**
*
* 三元运算符 当语句比较简单，使用问号表达式：条件成立执行: 前，否则执行：后语句
*
* 变量 = 布尔表达式？语句 1：语句 2
*/
System.out.println("--------------------------------");
int y;
y = i >= 5 ? i : -i;
System.out.println(y);
/**
* syitch 语句:
*
* 只要找到一个 case 语句就开始执行，所以拿 break 跳出 switch 代码，执行之后代码 int byte char short
* 不能接受其他类型
*/
System.out.println("--------------------------------");
switch (i) {
case 1:
System.out.println("你输入的是一");
break;
case 2:
System.out.println("你输入的是二");
break;
case 3:
case 4:
System.out.println("3,4");
break;
default:
System.out.println("你输入的大于二");
break;
}
while (i <= 10) {System.out.println(i++);
}
}
}② Float
public class Float_demo {public static void main(String[] args) {
// 最大浮点数 Infinity 幂指数为 254 有效的
System.out.println(Float.intBitsToFloat(0X7f800000));
// 比最大还大 NaN 幂指数为 255
System.out.println(Float.intBitsToFloat(0X7f800001));
// 最小浮点数
System.out.println(Float.intBitsToFloat(0X00000001));
System.out.println(Float.intBitsToFloat(0X50000000));
/**
* 区间
*/
Float x = 3.141f;
if (x > 3.14 || x < 3.15) {System.out.println(x);
} else {System.out.println("x 不在此区间");
}
}
}
正文完
