Java 基础语法(键盘录入数据，水仙花数，各类循环，random，数组，内存分配，方法，面向对象、封装、this、构造方法、标准类、API)
DAY1 基础语法
1 键盘录入数据，使用变量接收
导包、创建对象、接收数据
import java.util.Scanner;
Scanner sc = new Scanner(System.in);
int month = sc.nextInt;
2 if…else…if语句
if(){
} else if(){
} else if(){
} else{
}
3 switch语句
switch(month){
case X:
case X:
case X:
default:
}
4 for循环 水仙花数
需求：在控制台输出所有的“水仙花数”
①水仙花数是一个三位数
②水仙花数的个位、十位、百位数字立方和等于原数
分析：（以371为例）
①个位数字如何求？
371 1 371%10 = 1
②百位数字如何求？
371 3 371/100 = 3
③十位数字如何求？
371 7 371/10 = 37
371%10 = 7
371/10%10 = 7
注：任意数字的指定为上的数值如何求？
先使用整除操作将要求的数字移动到个位上，在使用取余操作取出最后一位上的值
123456789 5 先整除10000得到12345，再对10取余得到5
代码：
//在控制台输出所有的水仙花数
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
int count = 0;
for(int i = 100; i < 1000; i++)
{
int a = i % 10;//个位
int b = i / 10 % 10;//十位
int c = i /100;//百位
if(a*a*a + b*b*b + c*c*c == i) {
count++;
System.out.println(i);
}
}
System.out.println("水仙花数共有" + count +"个");
}
}
结果：
E:\作业\Java>javac Test.java
E:\作业\Java>java Test
153
370
371
407
水仙花数共有4个
5 while 循环
初始化语句
while(条件判断语句){
循环体语句;
条件控制语句;
}
6 do…while 循环
初始化语句
do{
循环体语句;
条件控制语句;
}while(条件判断语句)
7 循环嵌套
需求：在控制台输出一天的小时和分钟
//外循环控制小时的范围，内循环控制分钟的范围
for(int hour = 0; hour < 24; hour++)
{
for(int min = 0; min < 60; min++)
System.out.println(hour + "时" + min + "分");
System.out.println("---------");
}
8 Random
作用：产生一个随机数
//导包
import java.util.Random; //要在类定义上面
//创建对象
Random r = new Random();
//获取随机数
int number = r.nextInt(10); //获取数据的范围：[0,10)
//输出
System.out.println("number:" + number);
9 IDEA中的内容辅助键和快捷键
快速生成main()方法：psvm，回车
快速生成输出语句：sout，回车
ctrl+alt+space空格键(内容提示，代码补全等)
单行注释ctrl+/
多行注释ctrl+shift+/
格式化 ctrl+alt+L
10数组
数组的定义格式
int[] arr;//定义了一个int类型的数组，数组名是arr（推荐）
int arr[];//定义了一个int类型变量，变量名是arr数组
数组动态初始化
初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋值
数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[3];
等号左边：
int:数组的数据类型
[]:代表这是一个数组
arr:代表数组的名称
等号右边：
new:为数组开辟内存空间
int:数组的数据类型
[]:代表这是一个数组
3:代表数组的长度,元素个数
数组元素访问
数组变量访问方式
格式：数组名
数组内部保存的数据的访问方式
格式：数组名[索引]
public class array_demo {
public static void main(String[] args) {
int[] arr=new int[3];
//输出数组名
System.out.println(arr);
//输出数组元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
结果
数组静态初始化
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度
数据类型 [ ] 变量名 = new 数据类型[ ] { 数据1 , 数据2 , 数据3 , ……} ;
int [ ] arr = new int[ ] { 1 , 2 , 3 } ;
数据类型 [ ] 变量名 = { 数据1 , 数据2 , 数据3 , ……} ;
int [ ] arr = { 1 , 2 , 3 } ;
数组操作两个常见小问题
索引越界
访问量数组中不存在的索引对应的元素，造成索引越界问题
int[] arr=new int[3];
System.out.println(arr[3]);//索引越界
程序运行后，将会抛出ArrayIndexOutOfBoundsException 数组越界异常。
空指针异常
访问的数组已经不再指向堆内存的数据，造成空指针异常
null：空值，引用数据类型的默认值，表示不指向任何有效对象
int[] arr=new int[3];
System.out.println(arr[2]);
arr = null;//把null赋值给数组
System.out.println(arr[2]);//找不到了
arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时
候会抛出 NullPointerException 空指针异常。
两个操作
遍历
//定义数组
int[] arr = {11, 22, 33, 44, 55};
// 使用通用的遍历格式
for(int x=0; x<arr.length; x++)
{
System.out.println(arr[x]);
}
取最大值
//定义数组
int[] arr = {12, 45, 98, 73, 60};
//定义一个变量，用于保存最大值
// 取数组中第一个数据作为变量的初始值
int max = arr[0];
//与数组中剩余的数据逐个比对，每次比对将最大值保存到变量中
for (int x = 1; x < arr.length; x++) {
if (arr[x] > max) {
max = arr[x];
}
}//循环结束后打印变量的值
System.out.println("max:" + max);
11 内存分配
栈内存和堆内存
12 方法
带参数方法定义和调用
//常量值的调用
isEvenNumber(10);//10为实参
//变量的调用
int number = 10;
isEvenNumber(number);//number为实参
}
//需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数
public static void isEvenNumber(int number) {//这里的number为形参
if(number%2 == 0) {
System.out.println(true);
} else {
System.out.println(false);
}
}
实参和形参
实参：方法调用中的参数
形参：方法定义中的参数
带返回值的方法定义和调用
定义
public static 数据类型 方法名 ( 参数 ) {
return 数据 ;
}
public static boolean isEvenNumber( int number ) {
return true ;
}
public static int getMax( int a, int b ) {
return 100 ;
}
- 方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
调用
方法名 ( 参数 ) ; 数据类型 变量名 = 方法名 ( 参数 ) ;
isEvenNumber ( 5 ) ;
boolean flag = isEvenNumber ( 5 );
- 方法的返回值通常会使用变量接收，否则该返回值将无意义
方法的注意事项
- 方法不能嵌套定义
- void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
方法重载
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
- 多个方法在同一个类中
- 多个方法具有相同的方法名
- 多个方法的参数不相同，类型不同或者数量不同
注意： - 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
- 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载
正确范例
//返回值不同（无关）
//参数类型不同，是重载
public class MethodDemo {
public static void fn(int a) {
//方法体
}
public static int fn(double a) {
//方法体
}
}
//参数个数不同，是重载
public class MethodDemo {
public static float fn(int a) {
//方法体
}
public static int fn(int a, int b) {
//方法体
}
}
错误范例
/*错误原因：重载与返回值无关*/
public class MethodDemo {
public static void fn(int a) {
//方法体
}
public static int fn(int a) {
//方法体
}
}
/*错误原因：这是两个类的两个fn方法*/
public class MethodDemo01 {
public static void fn(int a) {
//方法体
}
}
public class MethodDemo02 {
public static int fn(double a) {
//方法体
}
}
方法重载练习
需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
思路：
①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
③定义所有的重载方法，两个byte类型与两个short类型参数
④完成方法的调用，测试运行结果
代码：
public class method_demo {
public static void main(String[] args) {
//调用方法
System.out.println(compare(10, 20));
System.out.println(compare((byte) 10, (byte) 20));
System.out.println(compare((short) 10, (short) 20));
System.out.println(compare(10L, 20L));
}
//int
public static boolean compare(int a, int b) {
System.out.println("int");
return a == b;
}
//byte
public static boolean compare(byte a, byte b) {
System.out.println("byte");
return a == b;
}
//short
public static boolean compare(short a, short b) {
System.out.println("short");
return a == b;
}
//long
public static boolean compare(long a, long b) {
System.out.println("long");
return a == b;
}
}
方法参数传递基本类型
public class ArgsDemo01 {
public static void main(String[] args) {
int number = 100;
System.out.println("调用change方法前：" + number);
change(number);
System.out.println("调用change方法后：" + number);
}
public static void change(int number) {
number = 200;
}
}
- 结论：
基本数据类型的参数，形式参数的改变，不影响实际参数 - 结论依据：
每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失
方法参数传递引用类型
public class ArgsDemo02 {
public static void main(String[] args) {
int[] arr = {10, 20, 30};
System.out.println("调用change方法前：" + arr[1]);
change(arr);
System.out.println("调用change方法后：" + arr[1]);
}
public static void change(int[] arr) {
arr[1] = 200;
}
}
-
结论：
对于引用类型的参数，形式参数的改变，影响实际参数的值 -
结论依据：
引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果
数组最大值
public class method_demo {
public static void main(String[] args) {
int[] arr = {11, 45, 23, 89, 34};
int arr_max = get_arr_max(arr);
System.out.println("arr_max:" + arr_max);
}
public static int get_arr_max(int[] arr) {
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
return max;
}
}
13 应用
逢七过
不死神兔
百钱百鸡
数组元素求和
public class arr_sum {
public static void main(String[] args) {
int[] arr = {68, 27,95,88,171,996,51,210};
int num = sum(arr);
System.out.println(num);
}
public static int sum(int[] arr) {
int s = 0;
for(int i = 0; i < arr.length; i++){
if(arr[i]%2 == 0 && arr[i]%10 != 7 && arr[i]/10%10 !=7){
s += arr[i];
}
}
return s;
}
}
DAY 2 面向对象
1 面向对象基础
- 类的定义步骤：
①定义类
②编写类的成员变量
③编写类的成员方法 - 创建对象的格式：
类名 对象名 = new 类名(); - 调用成员的格式：
对象名.成员变量
对象名.成员方法();
package study01;
//定义手机类
public class Phone {
//成员变量
String brand;
int price;
//成员方法
public static void call(){
System.out.println("打电话");
}
public static void sendMessage(){
System.out.println("发短信");
}
}
//定义手机测试类
public class phoneDemo {
public static void main(String[] args) {
//创建对象
Phone p = new Phone();
//使用成员变量
System.out.println(p.brand);
System.out.println(p.price);
p.brand = "小米";
p.price = 2999;
System.out.println(p.brand);
System.out.println(p.price);
//使用成员方法
p.call();
p.sendMessage();
}
}
2 成员变量和局部变量的区别【理解】
- 类中位置不同：成员变量（类中方法外）
局部变量（方法内部或方法声明上） - 内存中位置不同：成员变量（堆内存）
局部变量（栈内存） - 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）
局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失） - 初始化值不同：成员变量（有默认初始化值）
局部变量（没有默认初始化值，必须先定义，赋值才能使用）
3 封装
- 封装概述 是面向对象三大特征之一（封装，继承，多态） 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
- 封装原则 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法
- 封装好处 通过方法来控制成员变量的操作，提高了代码的安全性 把代码用方法进行封装，提高了代码的复用性
private是一个修饰符，可以用来修饰成员（成员变量，成员方法）
被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，
如果需要被其他类使用，提供相应的操作
- 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
- 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
package study02;
/* 学生类 */
class Student {
//成员变量
String name;
private int age;
//提供get方法
public void setAge(int a) {
if (a < 0 || a > 120) {
System.out.println("你给的年龄有误");
} else {
age = a;
}
}
public int getAge() {
return age;
}
//成员方法
public void show() {
System.out.println(name + "," + age);
}
}
/* 学生测试类 */
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
//给成员变量赋值
s.name = "林青霞";
s.setAge(30);
//调用show方法
s.show();
//使用get方法获取成员变量的值
System.out.println(s.name + "," + s.getAge());
}
}
4 this
this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
- 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
- (方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量)
public void setName(String name) {
this.name = name;// 上面的成员变量 = 此方法中的局部变量(赋值)
}
this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象
5 构造方法
作用：
创建对象 Student stu = new Student();
格式：
public class 类名{
修饰符 类名( 参数 ) {
}
}
功能：主要是完成对象数据的初始化
示例代码：
class Student {
private String name;
private int age;
//构造方法
public Student() {
System.out.println("无参构造方法");
}
public void show() {
System.out.println(name + "," + age);
}
}/* 测试类 */
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
s.show();
}
}
-
构造方法的创建
如果没有定义构造方法，系统将给出一个默认的无参数构造方法 如果定义了构造方法，系统将不再提供默认的构造方法 -
构造方法的重载
如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法
推荐的使用方式。无论是否使用，都手工书写无参数构造方法 -
重要功能！
可以使用带参构造，为成员变量进行初始化
/* 学生类 */
class Student {
private String name;
private int age;
public Student() {
}
public Student(String name) {
this.name = name;
}
public Student(int age) {
this.age = age;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public void show() {
System.out.println(name + "," + age);
}
}
/* 测试类 */
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s1 = new Student();
s1.show();
//public Student(String name)
Student s2 = new Student("林青霞");
s2.show();
//public Student(int age)
Student s3 = new Student(30);
s3.show();
//public Student(String name,int age)
Student s4 = new Student("林青霞", 30);
s4.show();
}
}
6 标准类制作
-
成员变量
使用private -
构造方法
提供一个无参构造方法
提供一个带多个参数的构造方法 -
成员方法
提供每一个成员变量对应的setXxx()/getXxx()
提供一个显示对象信息的show() -
（测试类中）
创建对象并为其成员变量赋值的两种方式
无参构造方法创建对象后使用setXxx()赋值
使用带参构造方法直接创建带有属性值的对象
应用
需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有
参创建的对象直接赋值，并通过show方法展示数据。
示例代码：
package study03;
class Student {
//成员变量
private String name;
private int age;
//构造方法
//无参构造方法
public Student() {
}
//有参构造方法
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//成员方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void show() {
System.out.println(name + "," + age);
}
}
/*------------------------------------
创建对象并为其成员变量赋值的两种方式
1:无参构造方法创建对象后使用setXxx()赋值
2:使用带参构造方法直接创建带有属性值的对象
*/
public class StudentDemo {
public static void main(String[] args) {
//无参构造方法创建对象后使用setXxx()赋值
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(30);
s1.show();
//使用带参构造方法直接创建带有属性值的对象
Student s2 = new Student("林青霞", 30);
s2.show();
}
}
7常用API
API
API (Application Programming Interface) ：应用程序编程接口
帮助文档
使用帮助文档
看什么？
看是否需要导包
看是用来干嘛的
看构造方法 、成员方法
练习
package study04;
import java.util.Scanner;
/*
Scanner:
一个简单的文本扫描器，可以使用正则表达式解析原始类型和字符串。
用于获取键盘录入数据。（基本数据类型）
public String nextLine():
获取键盘录入字符串数据
*/
public class ScannerDemo {
public static void main(String[] args) {
//用含参（System.in）构造方法（Scanner()）创建对象
Scanner sc = new Scanner(System.in);
//接收数据
System.out.println("请输入一个字符串数据：");
/*
Ctrl+Alt+V 只写右边sc.nextLine()，生成左边String line =
调用方法的时候，如果方法有明确的返回值，我们用变量接收
可以使用快捷键完成
*/
String line = sc.nextLine();
//输出结果
System.out.println("你输入的数据是：" + line);
}
}
下一篇待续…