使用专门的编译器，针对特定的平台，将高级语言源代码一次性的编译成可被该平台硬件执行的机器码，并包装成该平台所能识别的可执行性程序的格式。可以理解为有一个解释器，将所有的源代码编译成了硬件可以执行的机械码并直接执行，运行期间无需再次编译（速度快）
使用专门的解释器对源代码逐行编译成特定的硬件可执行的机械码并且直接执行
// 在dos命令行执行 javac HelloJava.java
// 执行 java HelloJava
// 输出结果：Hello JAVA
public class HelloJava{
public static void main(String[] args){
System.out.println("Hello JAVA");
}
}
abstract assert boolean break byte case
catch char class const continue default
do double else enum extends final finally
float for goto if implements import instanceof
int interface long native new package private
protected public return short static strictfp
super switch synchronized this throw throws
transient try void volatile while
// 这是一个单行注释
/*
这是一个多行注释，我是第一行
这是一个多行注释，我是第二行
*/
/**
这是一个DOC文档注释
*/
//JAVA中定义的标识符只能是 字母[a-z][A-Z]、下划线_、美元符号$ 开头
// 正确实例
int name;
int Name;
String _str;
String $str;
// 错误示例
int *1;
int #1;
/**
位bit是计算机最小的存储单位
1个字节byte 占据8位，也就是1byte = 8bit
*/
// 整数类型
byte 占据1个字节，范围为2^7 到 (2^7)-1
short 占据2个字节
int 占据4个字节
long 占据8个字节
// 浮点类型
float 占据4个字节
double 占据8个字节
// 字符类型
char 占据2个字节
// 布尔类型，值只有true或false
boolean 占据1位
// 在需要强制转换的变量前加入小括号 (数据类型)[变量名]
// 只有向下转型时需要使用强制转换（意思就是精度大的转换为精度小的需要强制转换）
// 强制转换时要注意丢失精度问题
long long1 = 10;
int int1 = (int)a1;
// 局部变量的作用域仅限于当前方法
// 成员变量只有创建了该类的实例才能使用
// 类变量用类即可调用，作用于当前类
// 使用了final修饰的变量就会变成一个常量
// 变量，顾名思义，可以被多次重新赋值的一个值
int a = 10;
int b = a++; // 先赋值再加1，值为10，该行结束后a为11
int c = ++a； // 先加1再复制，值为12
// 与 &&，两个都为true才为true， && 为断路与，只要左边为false，右边则不进行判断了
// 或 ||，两个都为false才为false，否则为true
// 非 ! ，将false取反为true，将true取反为false
& | ^ ~
/*
计算机底层在运算时，会将其转换为补码形式
1、正数的补码等于它的原码
2、负数的补码等于它的原码 （取反 +1） , 而负数的补码转换为原码的时候则需要 （-1 取反）也就是逆运算
3、补码与原码之间的转换时，最高位符号位不用取反
4、使用~进行取反的时候，符号也要取反
5、左移右移时记住一点细节，5>>3 = 5/(2^3) ，5<<3 = 5*(2^3)
*/
// 位运算的应用1：判断奇数偶数，一个数 &1，如果结果为1则是奇数，否则为偶数
int num = 10;
String result = (num & 1)==0 ? "偶数" : "奇数";
/*
位运算的应用2：使用异或^完成两个数之间的值交换
原理：一个数异或自己，再异或一个其他的数，就会变成那个其他的数，例如： 5 ^ 5 ^ 8 = 8，因为5^5之后结果得0，所以再^8时结果为8
两个数字a与b进行交换，a = a^a^b，b = b^b^a；可以看到一个规则，其中两个等式右边都有一个 a ^ b
*/
int a = 10;
int b = 20;
// 由于等式右边都有一个a ^ b
a = a ^ b;
// a 等于了 a^b时，b只需要用自己 ^ 一次a 就可以得到a的值
b = b ^ a;
// 而这个时候 a只需要再^一次自己当初的值即可得到b的值，自己的当初的值已经赋值给了b，所以再^ 一次b即可
a = a ^ b;
System.out.println("这时a的值等于：" + a + " b的值等于：" + b);
@author 作者名
@version 版本号
@since 指明最早使用的jdk版本
@parram 参数名
@return 返回值
@throws 所抛出的异常
生成javadoc时，需要使用的命令： javadoc -encoding utf-8 -charset utf-8
// switch语句中只能编写byte、short、int、char，在jdk1.7时可以使用String
递归就是方法自己调用自己，但是递归调用的空间复杂度较高，容易出现栈溢出
例如使用递归编写一个可以计算出阶乘的
public int factorial(int baseNum) {
if (baseNum == 1){
return 1;
}else {
return baseNum * factorial(baseNum - 1);
}
}
int[] arr1 = {1,2,3,4};String[] arr2 = {new String("s1"),new String("s2")};
int[] arr2 = new int[10];
可以理解为一个数组里装了多个一维数组
// 冒泡排序
public static void bubbleSort(int[] arr) {
// 确定循环次数
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if(arr[i] < arr[j]){
// 交换
arr[i] = arr[j] ^ arr[i];
arr[j] = arr[j] ^ arr[i];
arr[i] = arr[j] ^ arr[i];
}
}
}
}
// 选择排序
public static void selectSort(int[] arr) {
// 确定循环次数
for (int i = 0; i < arr.length - 1; i++) {
// 每次循环都需要得到一个最大或最小的值
for (int j = i + 1; j < arr.length; j++) {
if(arr[i] < arr[j]){
// 交换
arr[i] = arr[j] ^ arr[i];
arr[j] = arr[j] ^ arr[i];
arr[i] = arr[j] ^ arr[i];
}
}
}
}
权限修饰符 本类 当前包 不同包下的子类 不同包
private √
default(默认) √ √
protected √ √ √
public √ √ √ √
public class A {
public static void main(String[] args) {
Father father = new Son();
System.out.println(father.a);
System.out.println(father.b);
father.show();
father.staticShow2();
}
}
class Father{
int a = 10;
static int b = 20;
public void show(){
System.out.println("父类的成员方法");
}
public static void staticShow2(){
System.out.println("父类的静态方法");
}
}
class Son extends Father{
int a = 100;
static int b = 200;
@Override
public void show(){
System.out.println("子类的成员方法");
}
public static void staticShow2(){
System.out.println("子类的静态方法");
}
}
