Java学习记录1

1：输出：

（1）print:不自动进行换行。

（2）println:自动进行换行。

2：Helloworld：

public class Welcome {
	public static void main(String[] args) {
		System.out.print("hello world");
	}
}

3：变量的分类：

（1）局部变量：方法或语句块得不定义的变量。生命周期是从声明位置开始到方法或语句块执行完毕为止。

（2）成员变量（也叫实例变量 member variable）:方法外部、类的内部定义的变量。从属于对象，生命周期随对象终止。

（3）静态变量（类变量 static variable）：使用static定义。从属于类，生命周期伴随类终止，从类加载到卸载。

//常量：

常量（Constant）

变量前加“final”后变成常量。

常量赋值（规范）：大写字母和下划线组成。

4：基本数据类型：

（1）数值型

            1）整形类型：byte（1字节）、short（2字节）、int（4字节）、long（8字节）

            2）浮点类型：float（4字节）、double（8字节）

（2）：字符型：char（2字节）

（3）：布尔型：boolean（1字节）

只要类型比int小(即byte,char,short)，那么在运算之前，这些值会自动转换成int。

        注意：浮点数不精确，不能用来比较，java.math包下面有两个类：BigInteger和Decimal使用精确浮点运行，推荐：BigDecimal； boolean类型有两个常量值，true和false，在内存中占一位（不是一个字节），不可以使用0或非0的整数代替true和false（和C语言不同）

        例：

boolean man=true；
if（man）{      //相当于if(man==true)，但是极端不推荐
	system.outprintln(“男性”);
}

5：注释：

单行注释：使用“//”开头以“//”结尾

多行注释：以“/*”开头，以“*/”结尾

文档注释：以“/**”开头，以“**/”结尾

6：转义字符：

转义符	含义	Unicode值
\b	退格	\u0008
\n	换行	\u00a
\r	回车	\u000d
\t	制表符（tab）	\u0009
\"	双引号	\u0022
\'	单引号	\u0027
\\	反斜杠	\u005c

 7：算术运算符：

        整数运算符：                    

                 1、如果两个操作数一个为long，则结果也为long

                 2、没有long时，结果为int。即使操作数全为short，byte,结果也是int

        浮点运算：

                1、如果两个操作数有一个为double，则结果为double。

                2、只有两个操作数都是float，这结果才为float

        取模运算：              

                1、其操作数可以为浮点数，一般使用整数，结果是“余数”，“余数”符号和左边操                                 作数相同。如：7%3=0，-7%3=-1,7%-3=1。

8：输入：
        利用Scanner。（需要加头文件：import java.util.Scanner）

        例：

public class TestScanner{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入名字");
        String name = scanner.nextLine();
        
        System.out.println(name);
    }
}

9：方法（类似于C++中的函数）

        面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

        定义声明格式：

[修饰符1  修饰符2  …]   返回值类型    方法名(形式参数列表){
    Java语句；… … …
 }

        例：（通过对象调用普通方法）

public class TestMethod{
    public static void main(String[] args){
    //通过对象调用普通方法
    TestMethod tm = new TestMethod();
    tm.printSxt();
   }
    void printSxt(){
        System.out.println("学Java")；
        System.out.println("我爱Java")；
        System.out.println("啧啧啧")；
   }

}

        方法的重载：

        重载的方法实际上是完全不同的方法，只是名称相间而已。方法名相同，参数个数不同/参数类型不同/参数顺序不同，构成重载。

10：递归：

        基本思想：自己调自己 。

      1.定义递归头。（什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。）

      2.递归体。（什么时候需要调用自身方法。）

例：

public class Test22 {
    public static void main(String[] args) {
        long d1 = System.currentTimeMillis();  
        System.out.printf("%d阶乘的结果:%s%n", 10, factorial(10));
        long d2 = System.currentTimeMillis();
        System.out.printf("递归费时：%s%n", d2-d1);  //耗时：32ms
    }
    /** 求阶乘的方法*/
    static long  factorial(int n){
        if(n==1){//递归头
            return 1;
        }else{//递归体
            return n*factorial(n-1);//n! = n * (n-1)!
        }
    }
}

11：继承：

        关键词：extends

        使用格式：

    class 子类 extends 父类{}

12：final关键字的作用：

        （1）修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。

final  int   MAX_SPEED = 120;

        （2）修饰方法：该方法不可被子类重写。但是可以被重载!

final  void  study(){}

        （3）修饰类: 修饰的类不能被继承。比如：Math、String等。

final   class  A {}

13：super类：

        super是直接父类对象的引用，可以通过super来访问父类中被子类覆盖的方法或属性。

14：封装：

修饰符	同一个类	同一个包	子类	所有类
private	*
default	*	*
protected	*	*	*
public	*	*	*	*

15：数组：

        （1）数组的声明：

type[]   arr_name; 
type    arr_name[];

        注意：

      1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。

      2. 声明一个数组的时候并没有数组真正被创建。

      3. 构造一个数组，必须指定长度。

例：（创建基本类型一维数组）

public class Test {
    public static void main(String args[]) {
        int[] s = null; // 声明数组；
        s = new int[10]; // 给数组分配空间；
        for (int i = 0; i < 10; i++) {
            s[i] = 2 * i + 1;//给数组元素赋值；
            System.out.println(s[i]);
        } 
    }
}

例：（创建引用类型一维数组）

class Man{
    private int age;
    private int id;
    public Man(int id,int age) {
        super();
        this.age = age;
        this.id = id;
    }
}
public class AppMain {
    public static void main(String[] args) {
        Man[] mans;  //声明引用类型数组； 
        mans = new Man[10];  //给引用类型数组分配空间；
         
        Man m1 = new Man(1,11);
        Man m2 = new Man(2,22);  
         
        mans[0]=m1;//给引用类型数组元素赋值；
        mans[1]=m2;//给引用类型数组元素赋值；
    }
}

        （2）数组的初始化：

                1、静态初始化

int[] a = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；

                2、动态初始化

int[] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；

                3、默认初始化

int a2[] = new int[2]; // 默认值：0,0
boolean[] b = new boolean[2]; // 默认值：false,false
String[] s = new String[2]; // 默认值：null, null

        （3）数组的遍历

                通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。

例（使用循环遍历初始化和读取数组）：

public class Test {
    public static void main(String[] args) {
        int[] a = new int[4];
        //初始化数组元素的值
        for(int i=0;i<a.length;i++){
            a[i] = 100*i;
        }
        //读取元素的值
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
}

执行结果：

0
100
200
300

        （4）利用foreach循环输出数组

for(int m : a )  //a：数组名
    System.out.println(m);

注意：foreach循环只能用于读取数组元素的值，不能对其进行修改。