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 内涵:
1、一种编程语言
2、一套开发工具
3、一个运行环境
Android 是：具体的操作系统，可以用 java 语言来编写

java 中的对象：万物皆对象，指的是现实中存在的具体实例；·面向过程：[主 '谓' 宾]重点在谓语, 怎么操作？·面向对象
    ['主' 谓宾]重点是主语, 操作谁？·三大特征
    封装 继承 多态
·核心
    类与对象
    {类：是对一种事物的描述，是抽象的，概念上的定义        - 动物        ***
    {对象：是实际存在的某个该类事务的个体，也称为实例        - 猫，狗
    
private 私有的  public 公开的
    
四.1：类    
    一个类就是一个小的模块，尽可能的只公开必须让外部知道的内容，隐藏其他一切内容
    设计时避免一个类直接修改另一个类的数据
    模块设计：强内聚：许多功能尽量在类的内部独立完成，不让外面干预
        弱耦合：给外部尽可能少的方法调用
        
四.2：this 关键字
    - 一个类中的成员方法可以直接调用同类中的其他成员
    - 让该类的成员变量名和对其赋值的成员方法的形参变量同名
    
四.3：垃圾回收
    System.gc(); - 叫来垃圾回收器

静态对象被所有的实例对象所共享
属性作用域
方法中可以访问属性，但方法之间不能访问彼此内部定义的变量

静态方法

使用前不用创建任何对象

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 不在此区间");
        }
    }
}

一、java” 一次编译, 到处运行 ” 的跨平台性：

二、堆和栈内存？

三、java 和 Android 的区别：

四、面向对象

五、static

六、多线程

基础