Java入门学习(2)

发表于 | 分类于

java输入数据方法

  1. 从控制台接收一个字符，然后将其打印出来

    1
    2
    3
    4
    5
    6
    import java.io.*;
    public static void main(String [] args) throws IOException{ 
             System.out.print("Enter a Char:"); 
             char i = (char) System.in.read(); 
             System.out.println("your char is :"+i); 
    }

  2. 从控制台接收一个字符串，然后将其打印出来

    1
    2
    3
    4
    5
    6
    7
    8
    import java.io.*;
    public static void main(String [] args) throws IOException{ 
               BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
               String str = null; 
               System.out.println("Enter your value:"); 
               str = br.readLine(); 
               System.out.println("your value is :"+str); 
    }

  3. 用Scanner类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    import java.util.Scanner;
    public static void main(String [] args) { 
             Scanner sc = new Scanner(System.in); 
             System.out.println("请输入你的姓名："); 
             String name = sc.nextLine(); 
             System.out.println("请输入你的年龄："); 
             int age = sc.nextInt(); 
             System.out.println("请输入你的工资："); 
             float salary = sc.nextFloat(); 
             System.out.println("你的信息如下："); 
             System.out.println("姓名："+name+"\n"+"年龄："+age+"\n"+"工资："+salary); 
    }

最后小小的总结一下next()和nextLine()的区别：
在java中，next()方法是不接收空格的，在接收到有效数据前，所有的空格或者tab键等输入被忽略，若有有效
数据，则遇到这些键退出。nextLine()可以接收空格或者tab键，其输入应该以enter键结束。

Java数组排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//导入Arrays类
import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
        
		// 定义一个字符串数组
		String[] hobbies = { "sports", "game", "movie" };
        
		// 使用Arrays类的sort()方法对数组进行排序
		Arrays.sort(hobbies);
        
		// 使用Arrays类的toString()方法将数组转换为字符串并输出
		System.out.println(Arrays.toString(hobbies));
	}
}

使用foreach操作数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.Arrays;

public class HelloWorld {
    
    public static void main(String[] args) {
        
		// 定义一个整型数组，保存成绩信息
		int[] scores = { 89, 72, 64, 58, 93 };
        
		// 对Arrays类对数组进行排序
		Arrays.sort(scores);
        
		// 使用foreach遍历输出数组中的元素
		for (int score : scores ) {
			System.out.println(score);
		}
	}
}

二维数组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class HelloWorld {
    public static void main(String[] args) {
        
		// 定义两行三列的二维数组并赋值
		String[][] names={{"tom","jack","mike"},{"zhangsan","lisi","wangwu"}};
                 
		// 通过二重循环输出二维数组中元素的值
		for (int i = 0; i < names.length; i++) {
            
			for (int j = 0; j < names[i].length; j++) {
                
				System.out.println(names[i][j]);
			}
            
			System.out.println();
		}
	}
}

Java方法

排序输出

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
import java.util.Arrays;

public class HelloWorld {
    public static void main(String[] args) {
		HelloWorld hello = new HelloWorld();
		int[] scores={79,52,98,81};
        
		//调用方法，传入成绩数组，并获取成绩的个数
		int count=hello.sort(scores);
        
		System.out.println("共有"+count+"个成绩信息！");
	}
    
	/*
	 * 功能：将考试成绩排序并输出，返回成绩的个数
	 * 定义一个包含整型数组参数的方法，传入成绩数组
	 * 使用Arrays类对成绩数组进行排序并输出
	 * 方法执行后返回数组中元素的个数
	 */
	public int sort(int[] scores){
		Arrays.sort(scores);
		System.out.println(Arrays.toString(scores));
		
        //返回数组中元素的个数
        return scores.length;
	}
}

static 使用之静态变量

基于一个类创建多个该类的对象，每个对象都拥有自己的成员，互相独立。然而在某些时候，我们更希望该类所有>的对象共享同一个成员。此时就是 static 大显身手的时候了！！
静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收！

1
2
3
4
5
6
7
8
9
10
11
public class HelloWorld {
    
    // 定义静态变量，保存班级名称
	static String className = "JAVA";

	public static void main(String[] args) {
        
		// 访问静态变量，输出班级名称
		System.out.println(HelloWorld.className);
	}
}

static 使用之静态方法

  1. 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。
    如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。

  2. 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量.

  3. 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

初始化块

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
33
34
35
36
37
public class HelloWorld {
    
    String name; // 声明变量name
	String sex; // 声明变量sex
	static int age;// 声明静态变量age
    
    // 构造方法
	public HelloWorld() { 
		System.out.println("通过构造方法初始化name");
		name = "tom";
	}
    
    // 初始化块
	{ 
		System.out.println("通过初始化块初始化sex");
		sex = "男";
	}
    
    // 静态初始化块
	static { 
		System.out.println("通过静态初始化块初始化age");
		age = 20;
	}
    
	public void show() {
		System.out.println("姓名：" + name + "，性别：" + sex + "，年龄：" + age);
	}
    
	public static void main(String[] args) {
        
        // 创建对象
		HelloWorld hello = new HelloWorld();
		// 调用对象的show方法
        hello.show();
        
	}
}

Java封装

面向对象三大特性：封装、继承、多态

封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

封装的实现步骤

  1. 修改属性的可见性：设为private
  2. 创建getter/setter方法：用于属性的读写
  3. 在getter/setter方法中加入属性控制语句：对属性值的合法性进行判断