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);
}
}
下一篇待续…