面向过程的编程

• 1. java 中的元素

  • 关键字：编程已经规定好的单词或词组
  • 标识符：自定义取名(不能使用关键字); 只能由英文大小写、数字、美元符号; 且数字不能开头
  • 变量：会改变的量
  • 常量：不变的量、恒定
  • 注释：单行注释 / 开始 + /结尾；多行注释 / 开始 + /结尾；文档注释 /** 开始 + /结尾

• 2. 命名规范(见名知义)：

  • 创建工程，工程名：== 英文 + 版本号 ==；如：Tank_V1.0
  • 在 src 下创建包，包名：== 由一个单词构成, 全部小写 ==；如：com. 公司名.test
  • 创建类 Class(java 文件)，类名：== 首字母一定要大写 ==；如：TestOne
  • 创建方法，方法名：== 第一个单词的首字母一定要小写，遵循驼峰命名法 ==；如：mainTest
  • mian 方法：__java 的程序入口__
  • 定义变量，变量名：== 第一个单词的首字母一定要小写，遵循驼峰命名法 ==；如：resOne
  • 定义常量，常量名：== 全部大写，由多个单词构成用下划线隔开 ==；如：HOW_ARE_YOU

• 3. 数据类型

  • 编程的本质：各种数据的存储和运算

  • 电脑最小的存储单位：bit 位

1 字节 = 8 位
1 个字符 = 2 字节
1KB = 1024 字节
1MB = 1024KB

• 基本数据类型

  • 数字类型

类型	写法	型	占位	取值范围	例子
整数	byte	字节型	8 位	-128~127
	short	短整型	16 位	±30000
	int	整型	32 位	±20 亿左右
	long	长整型	64 位	±2^10^
小数	float	单精度浮点型	32 位	±3.4*10^38^
	double	双精度浮点型	64 位	±1.7*10^303^

        ●  文字类型

类型	写法	型	占位	取值范围	例子
字符型	char	仅仅表示一个字符	16 位	0~65535	‘a’ ‘b’ ‘ 我 ’

        ●  布尔类型

类型	写法	取值范围	例子
布尔型	boolean	true/false

引用数据类型（复合数据类型）：数组，类（对象类型），接口

• 4. 运算符

  • 算数运算符：+ – * / % ++ —
  • 关系运算符：> < >= <= == !=
  • 逻辑运算符：短路与 && 短路或 ||；与 & 或 |；非！；==(短路运算结果相同、效率不同，短路更高)==
  • 赋值运算符：= += -= *= /= %= 如：a+=b → a=a+b
  • 字符串拼接运算符：字符串和其他的数据进行拼接 结果还是一个字符串 String
  • 位运算（了解）：把数据转换成二进制的数：>> 右移、<< 左移、>>> 无符号右移、&、|、！、^ 异或、~ 取反
  • 三元运算符：格式：==(判断式)?a:b== 如果判断式为 true，则返回 a 的值，否则返回 b 的值
• 定义变量：数据类型 取个名字 = 值；
• 两个整数进行运算，结果一定是 == 整数 ==，如果想要出现小数，其中一个变量是 == 小数类型 double==
• 在混合运算中：char byte short → int → long → float → double
• 强制转换类型：(想转的类型)数据

练习

1. 新建一个 JAVA 工程 HelloJava，创建一个 test 包，新建一个 FristDemo 类，写一个 main 方法，定义两个 int 类型的变量 a 和 b，分别打印输出 a 与 b 的‘加 / 减 / 乘 / 除 / 取余’的结果。

package test;
public class FristDemo {public static void main(String[] args){
        int a = 4;
        int b = 2;
        System.out.println("a+b="+(a+b));
        System.out.println("a-b="+(a-b));
        System.out.println("a*b="+(a*b));
        System.out.println("a/b="+(a/b));
    }
}

2. 在 test 包下继续创建一个 SecondDemo 类，写一个 main 方法，定义一个 int 类型的变量 i，输出这个变量的 3 次方的结果。

package test;
public class SecondDemo {public static void main(String[] args) {
        int i = 2;
        System.out.println("i 的三次方 =" + ((int)Math.pow(i,3)));
    }
}

3. 在 test 包下继续创建一个 ThirdDemo 类，写一个 main 方法，定义两个 double 类型的变量 df 和 ds，分别将他们的‘加 / 减 / 乘 / 除的结果赋值给一个新的变量 res, 并打印输出每一个结果。

package test;
public class ThirdDemo {public static void main(String[] args){
        double df = 3;
        double ds = 6;
        double res = df+ds;
        System.out.println("df+ds="+res);
        res = df-ds;
        System.out.println("df-ds="+res);
        res = df*ds;
        System.out.println("df*ds="+res);
        res = df/ds;
        System.out.println("df/ds="+res);
    }
}

4. 新建一个工程 MyProject，创建一个 demo 包，新建一个 TestOne 类，在 main 方法中定义两个 boolean 类型的变量 flag 和 mark，将他们的“短路与”和“短路或”的逻辑运算结果赋值给新的变量 result，并打印输出这两个结果。

package demo;
public class TestOne {public static void main(String[] args){
        boolean flag= false;
        boolean mark= true;
        boolean result = flag && mark;
        System.out.println("短路与:"+result);
        result = flag || mark;
        System.out.println("短路或:"+result);
    }
}

5. 在 demo 包下继续新建一个 TestTwo 类，在 main 方法中定义三个 int 类型的变量 x y z，任意赋值，判断 (x+y) 与 z 的关系是“大于”时的结果，“小于”时的结果，“等于”时的结果，将三个结果赋值给一个变量 res，并打印输出每一个结果。

package demo;
public class TestTwo {public static void main(String[] args) {
        int x = 1;
        int y = 2;
        int z = 5;
        boolean res ;
        res = (x+y)>z?true:false;
        System.out.println("(x+y)>z 为:"+res);
        res = (x+y)<z?true:false;
        System.out.println("(x+y)<z 为:"+res);
        res = (x+y)==z?true:false;
        System.out.println("(x+y)= z 为:"+res);
    }
}

6. 在 demo 包下继续新建一个 TestThree 类，在 main 方法中定义三个 int 类型变量 x，y，z，求出三个数中最小的那个数是多少，打印输出。（用三元运算符）。

package demo;
public class TestThree {public static void main(String[] args){
        int x = 3;
        int y = 1;
        int z = 2;
        int min1 = x<y?x:y;
        int min2 = z<min1?z:min1;
        System.out.println("最小的数为:"+min2);
    }
}

7. 在 MyProject 这个工程中创建一个 hello 包，新建一个 TestSwap 类，在 main 方法中任意定义两个 int 类型的变量 a =13 和 b =7，交换 a 和 b 的值，并打印交换后的结果（两种方法）

package hello;
public class TestSwap {public static void main(String[] args) {
        int a = 13;
        int b = 7;
        // 第一种
        int z;
        z = a;
        a = b;
        b = z;
        System.out.println("第一种: 交换后 a =" + a + "" +"b=" + b);
        // 第二种
        int temp = a + b;
        a = temp - b;
        b = temp - a;
        System.out.println("第二种: 交换后 a =" + a + "" +"b=" + b);
        
        // 第三种
        swap(a, b);
        System.out.println("第三种: 交换后 a =" + a + "" +"b=" + b);
    }
    public static void swap(int a, int b) {
        a = 13;
        b = 7;
    }
}