Tag Archives: 基础

Java基本语法的几个笔记

Leave a reply

1 需要注意的点

1.1 运算赋值操作

  1. 复合赋值运算中(如：+=、-=等)，隐含了类型强制转换。如： 
    byte b = 126;
// 按常理2是int型，byte + int 结果应该是int，但这里会强转为byte
b += 2;  // 结果会溢出
System.out.println(b); // -128
  2. 三目运算不能单独存在，运算结果必须要有“接收方” 
    OperationDemo.java:10: 错误: 不是语句
               a > b ? a : b;
                     ^
1 个错误
  3. 整数类型中byte、short、int、long四种的前三种在运算时都会先转换为int类型； 
    byte a = 10;
byte b = 20;
// 事实上是byte = int + int，所以编译时会报错
byte ret = a + b;

    OperationDemo.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
               byte ret = a + b;
                            ^
1 个错误
  4. 如果表达式的右边为常量，编译时会先将表达的进行计算，用结果替换原来的表达式，如： 
    // 上述示例中ret = a + b，表达式右边是int型，左边是byte，有转换失真的风险所以编译会报错；
// 但如果右边是常量则不会，byte ret = 10 + 20类似直接写byte ret = 30;
byte ret = 10 + 20;

1.2 函数与方法

  1. 方法重载中如果返回值类型不一样，不构成方法重载。(想想看，返回值是可以强制类型转换的，那么编译器到底该给哪个方法呢？所以此处有歧异) 
    public static int sum(int a, int b) {
   return a + b;
}
// 编译报错，方法重名了，仅返回值类型不同不构成方法重载
public static float sum(int a, int b) {
   return (float) (a + b);
}

1.3 数组

  1. 数组初始化的几种方式，主要有静态初始化(指定值)与动态初始化(指定长度)；
  • 所谓的静态与动态区别是即时指定长度还是直接赋值；
  • Java中指定值有两种方式，一种是类型前缀，一种不加(所谓的标准格式与省略格式)；
  • 在其他高级语言中如C++，静态初始化不能拆开写(即省略格式)，但Java标准格式可以；
  • 动态初始化数组时，内存中全部写0，即int为0、float为0.0、对象为null、char为\u0000； 
    // 动态初始化，在创建数组时指定数组长度
int[] array1 = new int[10];
System.out.println(array1);
int[] array2 = new int[10];
System.out.println(array2);

// 静态初始化，创建数组时直接以数据长度为准
int[] array3 = new int[] {1, 2, 3, 4};
System.out.println(array3);
int[] array4 = {1, 2, 3, 4};
System.out.println(array4);

// 初始化可以先定义变量再赋值，但有一种情况例外
int[] array5;
array5 = new int[10];
int[] array6;
array6 = new int[] {1, 2, 3, 4};
int[] array7;
array7 = {1, 2, 3, 4}; // 注意：这种情况是非法的，编译报错

2 相关总结

2.1 类与对象

[……]

继续阅读

C++学习笔记

Leave a reply

1、C++编译过程
1.1、预处理，编译器将C++代码中的宏、引用等预处理指定进行展开，生成.i或.ii文件；
1.2、编译，编译器将展开后的文件进行编译生成汇编文件.s；
1.3、汇编，汇编器将汇编文件汇编生成链接文件.o或.obj；
1.4、链接，链接器将链接文件与库文件或第三方文件链接生成二进制文件，即可执行文件；
1.5、第一个C++程序

1
2
3
4
5
6
7
8

#include 
 
using namespace std;
 
int main(){
    cout << "Hello Cpp!!" << endl;
    return 0;
}

2、变量名三条定律
2.1、变量名只能是下划线、字母、数字；
2.2、首字母只能是下划线、字母；
2.3、不能是保留字/关键字；

3、C++常用数据类型
3.1、int –> 32位 -2147483648～+2147483647；
3.2、short int –> 16位 -32768～+32767；
3.3、long int –> 32位 -2147483648～+2147483647；
3.4、long long int –> 64位 -9223372036854775808 ~ +9223372036854775807；
3.5、float 32位 –> -3.4E-38～+3.4E+38；
3.6、double 64位 –> -1.7E-308～+1.7E+308；
3.7、char 8位 –> -128～+127；
3.8、关于精度的一个示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include 
#include 
 
using namespace std;
 
int main(){
    int i = 1234567890;
    float f = 1234567890123456789;
    double d = 1234567890123456789;
    long double ld = 1234567890123456789;
    cout << setprecision(20);
    cout << i << "n" << f << "n" << d << "n" << ld << endl;
    return 0;
}

1234567890
1234567939550609408
1234567890123456768
1234567890123456789
Program ended with exit code: 0

4、经典冒泡排序C++实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include 
 
using namespace std;
 
int main()
{
    // 数组、数组长度、循环次数
    int array[] = {128, 1, 11, 3, 33, 71, 2, 31, 4, 25, 61};
    int len = sizeof(array) / sizeof(array[0]);
    int loop_count = len - 1;
    // 冒泡次数循环
    for (int i = 0; i < loop_count; i++){
        // 单次冒泡比较循环
        for (int j = 0; j < loop_count - i; j++){ if (array[j] > array[j+1]){
                array[j] = array[j] + array[j+1];
                array[j+1] = array[j] - array[j+1];
                array[j] = array[j] - array[j+1];
            }
        }
    }
    for (int i = 0; i < len; i++){
        cout << array[i] << endl;
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include 
 
using namespace std;
 
int main()
{
    // 数组、数组长度、循环次数(最后一个数不需要比较)
    int array[] = {2, 1, 4, 3, 6, 5, 8, 7, 10, 9};
    int len = sizeof(array) / sizeof(array[0]);
    int loop_count = len - 1;
    for (int i = 0; i < loop_count; i++){
        // 调换前假设当前第一个为最小数
        int min_index = i;
        // 从第1个开始循环，可减少一次循环
        for (int j = i + 1; j < len; j++){
            if (array[j] < array[min_index]){
                min_index = j;
            }
        }
        // 如果第一个为最小数，不交换
        if (i != min_index){
            array[i] = array[i] + array[min_index];
            array[min_index] = array[i] - array[min_index];
            array[i] = array[i] - array[min_index];
        }
    }
    // 重新打印数组中的值(排序后)
    for (int i = 0; i < len; i++){
        cout << array[i] << " ";
    }
    return 0;
}

[……]

继续阅读