3. Java 语法基础类型条件语句数组

最新推荐文章于 2021-03-11 20:57:43 发布

简约AI

最新推荐文章于 2021-03-11 20:57:43 发布

阅读量530

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/refuil/article/details/51829119

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

3. Java 语法基础类型条件语句数组

标签： java

3.1 变量

–Java中的变量有四种：
•实例变量（成员变量）
•静态变量
•局部变量
•参数
–变量的命名
•任何变量名称都是以任意长度的Unicode编码的字符组成的，首字符必须是字母、美元符或者是下划线，后面跟字母、数字、美元符或下划线
–通常来说，我们建议类的名称以大写字母开头，成员变量以小写字母开头，静态变量以大写字母开头
–变量名称不能是Java的保留字：http://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
–如果常量，则以全大写字母组成，单词中间以下划线分隔
–多单词变量名称通常第一个字母小写，以后每个单词的第一个字母大写（驼峰方式——Camel back）
–熟悉Windows编程的同学可能知道匈牙利标记法（Hungarian Notation），Java没有对变量的命名方式有非常严格的要求，个人可选取适合自己的方式

 
 /**
 * This is a javadoc style comment
 * Pi =2 + 1/3(2 +2/5(2 + ...(n/2n+1)(2+ ......
 *
 */
import java.util.*;
public class CalcPi2 {
    // member variable
    private int[] piArray;    //实例变量
    private int maxRound;
    public CalcPi2(int rounds) {
        maxRound = rounds;
        piArray = new int[rounds];
        piArray[0] = 2;
    }
    public void calculate(int k)
    {
        int divide = 2*(maxRound - k) + 3;
        for(int i=1; i< maxRound; i++ )
        {
            int relay = piArray[i-1];
            piArray[i-1] = relay / divide;
            piArray[i] += (relay % divide) * 10000;
        }
        int multi = maxRound - k + 1;
        for(int i = maxRound-2; i>0; i--)
        {
            piArray[i] *= multi;
        }
        for(int i = maxRound-2; i>0; i--)
        {
            piArray[i-1] += (piArray[i])/10000;
            piArray[i] = (piArray[i])%10000;
        }
        piArray[0] += 2;
    }
    public void print() {
        System.out.print(piArray[0]);
        System.out.print('.');
        for (int i = 1; i < maxRound; i++) {
            System.out.print(piArray[i]);
        }           
    }
    public static void main(String[] args) {
        int rounds = 10;
        // output a hint
        System.out.print("Input rounds: ");
        try {
            // read value from console and convert to integer
            rounds =Integer.parseInt(System.console().readLine());
            // record time started
            long time1 = System.currentTimeMillis();
            // create a CalcPi2 instance
            CalcPi2 calc = new CalcPi2(rounds);
            // while loop
            int k = 1;
            while (k <= rounds) {
                calc.calculate(k);
                k++;
            }
            // record time finished calculation
            long time2 = System.currentTimeMillis();
            // output time taken.
            System.out.println("Time taken: " + new Long(time2 - time1).toString() + "ms");
            // print output
            calc.print();
        } catch (Exception e) {
            // catch exception and print stack trace
            e.printStackTrace();
        }
    }
}

3.2 Java基本类型

基本类型：每一个基本类型都有默认值，简单的记忆，就是0，对于char来说就是\u0000 –对于类变量来说取值都是null
–byte——8比特带符号
•byte a = 12;
–short——16比特带符号
•short a = 10;
–int——32比特带符号
•int count = 32;
–long——64比特带符号
•long count = 70084;
–float——32比特带符号
•float amout = 32.5f——注意后面的f，如果没有f，32.5是一个double类型，是不能赋值给float的
–double——64比特带符号
•double amout = 32.5

–boolean——布尔值，只有true，false两个取值  //区别于c/c++中，布尔型与整形是不同的，不能用0和1代表false/true

–char——16比特Unicode字符

 
 /**
 * This is a javadoc style comment
 * Pi =2 + 1/3(2 +2/5(2 + ...(n/2n+1)(2+ ......
 *
 */
public class CalcPi {
    // static constant variable
    public static final int MAX_ROUND = 2000;   //静态变量
    public static int[] PiArray = new int[MAX_ROUND];
    public static void CalcPi(int k)
    {
        int divide = 2*(MAX_ROUND - k) + 3;
        for(int i=1; i< MAX_ROUND; i++ )
        {
            int relay = PiArray[i-1];
            PiArray[i-1] = relay / divide;
            PiArray[i] += (relay % divide) * 10000;
        }
        int multi = MAX_ROUND - k + 1;
        for(int i = MAX_ROUND-2; i>0; i--)
        {
            PiArray[i] *= multi;
        }
        for(int i = MAX_ROUND-2; i>0; i--)
        {
            PiArray[i-1] += (PiArray[i])/10000;
            PiArray[i] = (PiArray[i])%10000;
        }
        PiArray[0] += 2;
    }
    public static void main(String[] args) {
        PiArray[0] = 2;
        for(int k=1; k<=MaxRound; k++)
        {
            CalcPi(k);
        }
        java.text.DecimalFormat format=new java.text.DecimalFormat("0000");
        for(int i=0; i<MAX_ROUND-1; i++)
        {
            System.out.print(format.format(PiArray[i]));
        }
    }
}

3.3 Java对象类型

–每一个类，只要可以生成实例，都可以有相应的变量，每个变量就是这个类的一个实例
–Java中可能使用最多的就是java.lang.String
•String name = “abc”;
–Java中，有些实例的状态是可以改变的，有些实例的状态是不可以改变的，叫做Immutable，在使用这些Immutable的实例的时候要特别注意，有可能会引起大量的内存占用
•例如：String a = “a” + “b”; 虽然只定义了一个String变量，但是实际产生了两个
•对于String的合并，可以使用StringBuilder进行处理，减少内存的消耗

3.4 表达式、声明、块

表达式——表达式是由变量、运算符、方法调用组成的结构

 
 int a = 1;
if (a == 1)
System.out.println(“True”);

声明——声明是一个完整的执行单元，必须以;结尾
–aValue = 124;
块——块是由一个或者多个声明组成的执行单元，每个块由{开始，到}结束
–在块中声明的变量，其作用域仅限于块的内部，在外部无法访问
–注意，块的内部声明的局部变量不要用与外部的变量一样的名称

3.5 流转控制if、switch、while、do-while、for

流转控制声明
–If-else
if (条件) {
} // 块
else if (条件) {
} // 块
else {
} // 块
•如果块内只有一句语句，可以不用{}，但是作为一个习惯，建议始终使用
–Switch——与if-else类似，只能作用于long以外的整型、枚举类型以及String上

 
 switch (变量) {
    case 1:
        break;
    default:
        break;
}

3.6 声明构造函数

–格式：作用域类名(参数列表)
–作用域可为public，protected，private，或不指明
–用于创建一个类的实例
–参数列表：参数类型参数名称[, 参数类型参数名称]*，或为空，表示没有输入参数
声明方法
–格式：修饰符作用域返回类型方法名称(参数列表)
–作用域同上
–修饰符可为static，和/或 final
–返回类型为返回值的类名或基础类型名称，没有返回值则为void
–具有返回类型的方法必须在每个执行的路径上返回

3.7 Java的内存管理

–程序的内存分为heap和stack两个部分
•局部变量、方法调用消耗stack的内存
•类的实例、数组，消耗heap的内存
•Stack的内存是连续分配的，因此分配、释放速度很快，但是stack内存数量有限，Windows上默认2MB，Linux默认1MB
•Heap上的内存是不连续分配的，在进行内存分配的时候首先要找到一个连续的，足够容纳所需内存块大小的空闲内存，然后进行分配，因此可能会出现大量碎片，造成总空闲内存足够，但是无法分配的情况

 
 public class Fibonacci2 {
    public static int calculate(int value) {
        switch (value) {
            /*case 0:
                return 0;
            case 1:
                return 1;
            case 2:
                return 1;*/
            default:
                return Fibonacci2.calculate(value - 1) + Fibonacci2.calculate(value - 2);    #当递归出现过度调用，会出现stackover的情况，因为内存分配太多没有及时处理
        }
    }
    public static void main(String[] args) {
        int value;
        System.out.print("Input: ");
        value = Integer.parseInt(System.console().readLine());
        System.out.println("Result: " + new Integer(Fibonacci2.calculate(value)).toString());
        for (int i = 1; i <= value; i++) {
            System.out.print(new Integer(Fibonacci2.calculate(i)).toString() + " ");
        }
    }
}

3.8 数组

1，数组：是一组相关数据的集合，数组中的数据类型一定是完全相同；
2，数组的三种类型：一维数组、二维数组、多维数组；
3，要使用数组，首先要声明数组，然后要分配具体的内容给数组;

 
         int scores[] = null;
        scores = new int[10];
        for(int x =0; x < 10; x++)
            System.out.println(scores[x]);

4，在内存的栈中保存数组的名字，而在内存的堆中则保存数组的具体内容，数组的名字会具体指向数组的内容，从而可以通过数组的名字加上数组内容索引的方式来访问数组中具体的内容；在栈中保存的永远是数组的名称，必须通过new关键字在堆中为当前的数组开辟堆内存空间并赋（初始）值，此时栈中的数组的名称会指向堆中分配的数组空间的首地址；
5，数组中有一些类同类型的元素，每个元素的访问可以通过数组的名称加上元素的索引位置来共同完成，数组的索引位置是从0开始的，例如访问数组中的第三个元素scores[2];
6，数组长度的访问是通过数组的length方法，例如scores.length
7， int scores[] = {1,2,3,4,5}; //使用静态初始化声明数组
8, 二维数组：
8.1，二位数组相当于一个表格，数组中的每一个元素又是数组；

 
 int scores[][];
scores = new int[5][2];
for(int i =0; i< scores.length; i++){
    for(int j =0; j < scores[i].length; j++)
        System.out.print(scores[i][j] + "\t");
    System.out.println();
}

8.2，使用静态初始化的方式实例化二维数组可能让元素类型为数组的具体的每一个元素的内容的长度不同：

 
 int scores[][] = {{10,2},{1,2,23,3,4},{22,33,44,555,666,77}};
for(int i =0; i< scores.length; i++){
    for(int j =0; j < scores[i].length; j++)
        System.out.print(scores[i][j] + "\t");
    System.out.println();
}

3.9 注释

–可以/** */作为javadoc注释  
–可以/* */作为内部整段注释
–可以//单行注释

eg:

 
 import java.util.*;

util是utiliy的缩写，意为多用途的，工具性质的包
这个包中主要存放了：集合类（如ArrayList，HashMap等），随机数产生类，属性文件读取类，定时器类等类。
这些类极大方便了Java编程，日常java编程中，经常要用到这些类。

3.10 java中方法的定义与使用

3.10.1 方法的重载：函数名称相同，但传递的函数的参数类型或者参数个数不同：

 
 public class plus{
public static void main(String[] args){
    int content = sum(3,5,10);
    System.out.println("x+y+z = " + content);
}
public static int sum(int x, int y){
    int result = 0;
    result = x+y;
    return result;
}
public static int sum(int x, int y, int z){
    int result = 0;
    result = x + y +z;
    return result;
}
}

3.10.2 返回值不作为重载的判定

方法重载只考虑在函数名称相同的情况下不同的输入参数类型和参数的个数，不考虑函数返回值的类型（也就是如果函数名称及其参数类型和个数完全相同的情况下，如果仅仅是返回值类型不同，则不能算作方法重载）

3.10.2 数组作为方法的参数

 
 public class BubbleSort{
    public static void main(String[] args){
        int scores[] = {99,97,98,100,98,88,87};
        sort(scores);
        for(int score : scores)
            System.out.println(score + "\t");
    }
private static void sort(int[] scores){
    for(int i = 1; i< scores.length; i++){
        for(int j =0; j < scores.length; j++){
            if(scores[i] < scores[j]){
                int x = scores[i];
                scores[i] = scores[j];
                scores[j] = x;
            }
        }
    }
}
}

此时传递给方法的只是数组的引用，在方法内部改变数组引用所指向的具体的数组的内容实际上就改变了数组本身！

简约AI

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
3. Java 语法基础类型条件语句数组

3. Java 语法基础类型条件语句数组标签： java3.1 变量–Java中的变量有四种： •实例变量（成员变量） •静态变量 •局部变量 •参数 –变量的命名 •任何变量名称都是以任意长度的Unicode编码的字符组成的，首字符必须是字母、美元符或者是下划线，后面跟字母、数字、美元符或下划线 –通常来说，我们建议类的名
复制链接

扫一扫