本周总结
一、switch语句的应用
键盘录入月份的值(默认int),请使用switch来完成,判断季节
(3,4,5 春季,6,7,8 夏季,9,10,11 秋季,12,1,2冬季)
代码:
//导包
import java.util.Scanner ;
class SwitchTest2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个月份的值:") ;
int month = sc.nextInt() ;
//使用switch语句接受数据
switch(month){
case 3:
case 4:
case 5:
System.out.println("春季");
break ;
case 6:
case 7:
case 8:
System.out.println("夏季");
break ;
case 9:
case 10:
case 11:
System.out.println("秋季");
break ;
case 12:
case 1:
case 2:
System.out.println("冬季");
break ;
default:
System.out.println("对不起,您输入的月份有误.");
break ;
}
}
}
二、循环语句
1、循环语句----for
格式
for(初始化语句;条件表达式;步长/控制体语句){
循环体语句;
}
执行流程
1)执行初始化化语句:给变量进行赋值
2)满足条件:成立
3)执行循环体语句
4)执行步长/控制体语句
再次执行2)过程,判断条件是否成立
依次循环
...
...
当条件表达式不成立,则for语句结束!
举例
使用for循环语句求1-10之间的和?
class demo{
public static void main(String[] args){
int temp=0;
for(int x=1;x<=10;x++){
temp=temp+x;
}
System.out.println("1-10之间的数据和是:"+sum) ;
}
}
2、 循环语句----while
格式
while循环语句格式:
基本格式
while(判断条件语句) {
循环体语句;
}
扩展格式
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
执行流程
1)初始化话语句进行赋值
2)条件表达式成立,
执行循环体语句
再次执行控制体语句
3)再次判断条件表达式是否成立,
…
…
当条件不成立,则while结束
举例
计算1-100的和?
public static void main(String[] args) {
//使用while循环实现
//定义一个变量,记录累加求和
int sum = 0;
//定义初始化表达式
int i = 1;
//使用while循环让初始化表达式的值变化
while(i<=100){
//累加求和
sum += i ;
//步进表达式改变变量的值
i++;
}
//打印求和的变量
System.out.println("1‐100的和是:"+sum);
}
for和while的区别
1)从格式上来讲:格式不同
for(初始化语句;条件表达式;控制体语句){
循环体语句;
}
初始化语句;
while(条件表达式){
循环体语句;
控制体语句;
}
for循环结束之后,不能在访问for中变量,for循环结束;
变量需要被释放掉了!
while循环可以访问
2)内存:for循环节省内存空间
堆,栈内存(存储局部变量:在方法定义中/方法声明上的变量),
方法区..(main())
for循环结束,变量随着被释放掉,节省内存空间;(不能访问这个变量了.)
while循环结束,依然可以访问这个变量,比较消耗内存空间...
3)使用场景:
for循环:明确循环次数使用 水仙花数:100-999 (开发中:优先考虑for)
while循环:不明确循环次数,使用
3、 死循环
//两种格式:
//1)
for(;;){
循环体语句;
}
//2)
while(true){
循环体语句;
}
示例
class DieForWhileDemo{
public static void main(String[] args){
//for的死循环格式:
for(;;){
System.out.println("死循环...") ;
}
//while循环
while(true){//恒成立
System.out.println("死循环...") ;
}
}
}
4、循环语句—do_while
格式
初始化语句;
do{
循环体语句;
控制体语句;
}while(条件表达式) ;
扩展格式
初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);
do…while循环的特点
无条件执行一次循环体,即使我们将循环条件直接写成false,也依然会循环一次。
举例
计算1-100的和?
class DoWhileDemo{
public static void main(String[] args){
//1-100之间的和
//定义一个最终结果变量
int sum = 0 ;
int x = 1 ;
do{
sum += x ;
x ++ ;
}while(x<=100) ;
System.out.println("1-100之间的和是:"+sum) ;
5、for循环嵌套
概念:
一个for循环语句作为另一个for循环语句的循环
格式
for(初始化语句;条件表达式;控制体语句){
for(初始化语句;条件表达式;控制体语句){
}
}
举例
打印"**"形(4行5列的*)
class ForForDemo{
public static void main(String[] args){
for(int x = 0 ; x < 4 ; x++){ //外层循环:就是一个控制行数
for(int y = 0 ; y < 5 ; y ++){//内层循环:控制列数
System.out.print("*") ; //在同一行输出5个*
}
System.out.println() ;
}
}
}
三、跳转控制语句
1、break
break :结束中断,结束循环(不能单独使用)
使用场景:终止switch或者循环
在选择结构switch语句中
在循环语句中
离开使用场景的存在是没有意义的
使用示范
class BreakDemo{
public static void main(String[] args){
for(int x = 0 ; x < 10 ; x ++){
//判断
if(x == 3){
break ;
}
System.out.println(x) ;//0,1,2
}
System.out.println("over") ;
}
}
2、continue
continue:继续, 在循环中使用 ,
结束当前循环,立即进入下一次循环
使用示范
class ContinueDemo{
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
//需求:不打印第三次HelloWorld
if(i == 3){
continue;
}
System.out.println("HelloWorld"+i);
}
}
3、return
Return关键字不是为了跳转出循环体,更常用的功能是结束一个方法,也就是退出一个方法。跳转到上层调用的方
法。
使用示范
class ReturnDemo{
public static void main(String[] args){
//程序:引入 return
System.out.println("程序开始了....") ;
for(int x = 0 ; x < 10 ; x ++){
System.out.println("进入for循环了...") ;
if(x==3){
return ; //单独使用,return:结束方法的
}
System.out.println(x) ;//0,1,2
}
System.out.println("程序结束了...") ;
}
}
return 是需要和方法相关的使用的,单独使用非常少
四、方法
概念
方法: 就是使用{}代码块包起来,并且起一个名字(见名知意)
Java中定义方法的格式:
1)有具体返回值类型的方法的定义
固定格式
public static 返回值类型 方法名(参数类型1 变量名1,参数类型2 变量名2....){
方法中的业务逻辑代码...
return 结果;
}
public: 访问权限足够大,公共的
static: 静态修饰符(面向对象中讲)
返回值类型:就是数据类型(目前使用的基本数据类型...)
方法名: 见名知意 (小驼峰命名法)
参数类型:第一个参数的数据类型
变量名:符合 (小驼峰命名法)
return 结束方法以及返回方法指定类型的值
返回值 程序被return带回的结果,返回给调用者
有具体返回值类型的方法的调用:
1)单独调用(不用它)
2)输出调用:不建议:因为 直接输出,想使用这个结果值进行操作就不可以了
3)赋值调用:推荐
注意事项
1)方法和方法是平级关系,不能进行嵌套: 在一个方法中定义另一个方法不允许
2)在Java中,定义方法的时候形式参数必须携带数据类型!
(Java是一个强类型语言
Javascript:弱类型语言:定义函数的,参数不需要带类型)
3)调用方法的时候,传递的实际参数不需要在携带数据类型了
4)定义方法的时候: 有{括号的地方不能有分号;
举例
class FunctionDemo{
public static void main(String[] args){
int a = 30 ;
int b = 20 ;
int result = sum(a,b) ;
System.out.println(result) ;
}
public static int sum(int a,int b){//形式参数
int result = a + b;//30+20
return result ;
}
}
2)没有具体返回值类型的方法的定义:
针对某个功能代码块{} 没有具体的返回值类型,按照语法规定:必须有一个值
Java提供了一个关键字:代替没有具体返回值类型 void
固定格式:
public static void 方法名(形式参数列表){
方法体中的内容;
}
举例
键盘录入一个数据a(1<=a<=9),输出对应的nn乘法表
import java.util.Scanner;
ublic class Homework {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入a的值");
int a = sc.nextInt();
chengFaBiao(a);
}
public static void chengFaBiao(int a) {
for (int x = 1; x <= a; x++) {
for (int z = 1; z <= x; z++) {
System.out.print(z + "*" + z + "=" + z * z + "\t");
}
System.out.println();
}
}
}
—方法重载
方法重载(overload) :
方法名相同,参数列表不同,与返回值无关!
参数列表不同:
1)参数个数不同
2)参数类型不同
方法重载的目的:
就是为了提高某个功能的扩展性
在有的时候:同一个方法,可以传递任何数据类型
方法重载的特点
返回值类型无关,只看方法名和参数列表
在调用时,虚拟机通过参数列表的不同来区分同名方法
方法的形式参数问题:
1)如果方法的形式参数是基本数据类型,有什么特点?
形式参数的改变不会影响实际参数!
2)如果方法的形式参数是引用数据类型(数组),有什么特点?
String类型:特殊的引用类型:它作为形式参数,效果和基本数据类型一致!
形式参数的改变不影响实际参数(String本质就是常量)
如果形式参数是数组类型(除String类型外),
实际参数传递:传递数组对象 :形式参数的改变会直接影响实际参数
五、数组
数组概念:
就是存储多个数据的容器,必须保证容器中的数据类型一致!
数组的定义格式:
1)动态初始化
给定了数组的长度,系统默认对元素进行初始化!
格式:
数据类型[] 数组名称 = new 数据类型[数组长度] ;
数据类型 数组名称[] = new 数据类型[数组长度] ;
2)静态初始化
我们给定的具体的元素,数组长度由系统确定
格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;
简化格式:
数据类型[] 数组名称 = {元素1,元素2,元素3....} ;
数据类型 数组名称[] = {元素1,元素2,元素3....} ;
程序报错(了解):
编译时期异常:jvm运行java程序:检查语法 (调用者必须处理!)
后期:IOEXception: 读写数据时
ParseExceptin:解析异常
将"2021-7-13" 日期文本格式---->java.util.Date
运行时期异常:RuntimeException
代码逻辑不严谨或者其他业务判断导致的出现问题
ArrayIndexOutOfBoundsException:
数组角标越界异常
开发者:需要检查数组的角标是否正确!
NullpointerException:空指针异常:
描述:当前某个对象为null,我们还要使用对象操作,就会出现问题了
都是可以通过逻辑判断解决
针对某个对象进行非空判断
静态初始化应用
将int[] arr = { 43, 65, 3, 6, 76 };进行遍历
public class work01 {
public static void main(String[] args) {
int[] arr = { 43, 65, 3, 6, 76 };
System.out.println("遍历后:");
bianLi(arr);
}
public static void bianLi(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.println(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
}
}
数组高级排序------冒泡
冒泡排序思想:
两两比较,较大的值往后放,第一次比较完毕,最大值出现在最大索引处
依次这样比较,可以得到排好序的数组!
编写程序,已知数组int[] arr = {43,65,3,6,76},
对数组—冒泡进行排序之后,然后进行遍历输出结果;
public class work01 {
public static void main(String[] args) {
int[] arr = { 43, 65, 3, 6, 76 };
System.out.println("排序前:");
bianLi(arr);
System.out.println("遍历排序后");
paiXu(arr);
bianLi(arr);
}
public static void paiXu(int[] arr) {
for (int x = 0; x < arr.length - 1; x++) {
for (int y = 0; y < arr.length - 1; y++) {
if (arr[y] > arr[y + 1]) {
int num = arr[y];
arr[y] = arr[y + 1];
arr[y + 1] = num;
}
}
}
}
public static void bianLi(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.println(arr[i] + "]");
} else {
System.out.print(arr[i] + ",");
}
}
}
}
Java中的内存分配
Java 程序在运行时,需要在内存中的分配空间。为了提高运算效率,就对空间进行了不同区域的划分,
因为每一片区域都有特定的处理数据方式和内存管理方式。
栈: 存储局部变量
堆 :存储new出来的东西
方法区:自定义的方法/jdk提供的方法
本地方法区:(和系统相关)
寄存器:(给CPU使用)
六、面向对象
1、引入
面向对象基于面向过程:
面向过程: (自己就是执行者) 代表:c语言
1)需求分析
2)定义功能代码块(方法)
3)在main 方法调用,显示结果
面向对象:代表java语言
需要找一个对象完成一件事件:比如 :键盘录入一个数据 (jdk提供--->Scanner)
创建键盘录入对象
提示并录入数据
展示结果
2、面向对象的思想特点:
1)更符号我们生活中是思想行为习惯
2)让复杂的事情简单化
3)我们从执行者变成了指挥者
3、 面向对象的三大特征:
封装,继承,多态
4、面向对象的设计理念:
不断的去创建对象,使用对象,指挥对象做事情! (Scanner:键盘录入)
4、类与对象的关系
类:是一组相关的属性和行为的集合
对象:是该类事物的具体体现
举例: 类 学生 对象 班长就是一个对象
类:可以理解为构造对象的一个蓝图或者模版,是抽象的概念
对象:是以类为模型创建的具体实例,是对类
的一种具体化。
5、类的定义
现实世界的事物 属性 人的身高,体重等 行为 人可以学习,吃饭等
Java中用class描述事物也是如此 成员变量 就是事物的属性 成员方法 就是事物的行为 定义类其实就是定义类的成
员(成员变量和成员方法)
例题
定义一个计算器类,提供加减乘除的功能,并进行测试(在Test测类中进行测试,可以键盘录入两个数据进行测试)
提示:计算器英文单词:Caculator
在这个类中提供 四个成员方法:加减乘除
import java.util.Scanner;
class Caculator {
public void add(int a, int b) {
int temp = a + b;
System.out.println("a+b的值是:" + temp);
}
public void jian(int a, int b) {
int temp = a - b;
System.out.println("a-b的值是:" + temp);
}
public void cheng(int a, int b) {
int temp = a * b;
System.out.println("a*b的值是:" + temp);
}
public void chu(int a, int b) {
int temp = a / b;
System.out.println("a/b的值是:" + temp);
}
}
class CaculatorDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请依次输入两个数");
int a = sc.nextInt();
int b = sc.nextInt();
Caculator caculator = new Caculator();
caculator.add(a, b);
caculator.jian(a, b);
caculator.cheng(a, b);
caculator.chu(a, b);
}
}
6、成员变量和局部变量
成员变量:
1、成员变量定义在类中,在整个类中都可以被访问。
2、成员变量随着对象的建立而建立,随着对象的消失而消失,存在于对象所在的堆内存中。
3、成员变量有默认初始化值。
局部变量:
1、局部变量只定义在局部范围内,如:函数内,语句内等,只在所属的区域有效。
2、局部变量存在于栈内存中,作用的范围结束,变量空间会自动释放。
3、局部变量没有默认初始化值
区别
1)在程序中的书写位置不同:
局部变量:方法定义或方法声明上
成员变量:在类中,成员方法外定义的变量
2)在内存中
局部变量:在栈内存中
成员变量:在堆内存中
3)生命周期不同
局部变量:随着方法调用而存在,随着方法调用完毕而消失
成员变量:随着对象的创建而存在,随着对象创建完毕之后,不会立即消失,需要等待GC(垃圾回收器)空闲时候回收掉
4)初始化不同
局部变量:可以先定义,但是必须在使用之前赋值,否则:可能尚未初始化变量
成员变量:可以不初始化,它存在系统默认初始化(根据类型判定)
形式参数问题
/*
需求:访问Demo类中的show方法?
*/
//程序类
class Programmer{
public void coding(){
System.out.println("程序员根据需求写代码...") ;
}
}
//定义Demo类
class Demo{
//有一个成员方法
public void show(Programmer programmer){//如果方法的形式参数是一个引用类型:类---就需要创建当前类对象
programmer.coding() ;
}
}
class Test{//测试类
public static void main(String[] args){
//创建Demo类对象
Demo d = new Demo() ;
//创建Programmer类的对象
Programmer pro = new Programmer() ;
d.show(pro) ;
}
}
7、 匿名对象
概念
顾名知意:没有名字的对象,是对象的一种简化表示形式
格式
new 类名() ;
匿名对象有一个特点:可以作为参数进行传递
在开发中,匿名对象使用一次即可!
(因为没有栈内存变量指向堆内存地址,
直接是在堆内存开辟空间,使用完毕,立即被回收!)
8、封装
封装概述
是指隐藏对象的属性和实现细节,仅对外提供公共访问方式
好处:
隐藏实现细节,提供公共的访问方式
提高了代码的复用性
提高安全性。
封装原则:
将不需要对外提供的内容都隐藏起来。
把属性隐藏,提供公共方法对其访问。
封装目的:
为了保证的数据的安全性!
private关键字:
特点
1)可以修饰成员变量,也可以修饰成员方法,但是都只能在本类访问,外界类不能够访问
2)这些被私有修饰的成员变量,或者成员方法,可以间接通过公共方法来访问!
为了将某个类的成员属性隐藏(将属性(成员变量)“私有化”),
并为之提供公共(public)访问方式!(setXXX()/getXXX())
私有化:就是关键字"private" 只能在本类中访问
示例
class Student2{
//成员变量私有化
private String name ;//姓名
private int age ; //年龄
private String gender ;//性别
private String hobit ; //爱好
//成员方法
public void study(){
System.out.println("学习JavaEE...") ;
}
//玩游戏
public String playGame(String gameName){
return "会玩"+gameName ;
}
//运行
public void sport(){
System.out.println("喜欢踢足球...") ;
}
//一些公共访问方法:给姓名,年龄,性别,爱好赋值 /还需要获取这些内容
//给学生的姓名赋值
public void setName(String n){ //"高圆圆"
name = n ;//name = n = "高圆圆"
}
//获取学生的姓名--->返回值:String
public String getName(){
return name ;
}
//给学生的年龄赋值
public void setAge(int a){ //41
age = a ; //age = a = 41
}
//获取学生的年龄:int类型
public int getAge(){
return age ;
}
//给学生的性别赋值
public void setGender(String g){ //"女"
gender = g ; //gender = g ="女"
}
//获取学生的性别:String
public String getGender(){
return gender ;
}
//给学生的爱好赋值
public void setHobit(String h){ //"跑步"
hobit = h ; //hobit = h = "跑步"
}
//获取学生的爱好:String
public String getHobit(){
return hobit ;
}
}
//测试类
class StudentTest2{
public static void main(String[] args){
//创建学生类测试
Student2 s = new Student2() ;
//对象名.公共的成员方法名() 赋值
s.setName("高圆圆") ;
s.setAge(41) ;
s.setGender("女") ;
s.setHobit("跑步") ;
System.out.println("当前学生的姓名是:"+
s.getName()+",年龄是:"+s.getAge()+",性别是:"+s.getGender()+",爱好是:"+s.getHobit()) ;
//其他成员方法
s.study() ;//学习
String str = s.playGame("lol") ;
System.out.println(str) ;
s.sport() ;
}
}
this关键字
this:代表所在类的对象引用
this:就是代表当前类的对象的地址值引用!
给属性赋值的时候:局部变量隐藏了成员变量:名称都是一样的
Java此时提供关键字this:解决局部变量隐藏了成员变量
this.成员变量名 = 局部变量;
使用示例
学生事物
属性:姓名,年龄,性别
行为:学习,抽烟…
学生类进行描述学生事物—加入封装思想并加入this关键字
class Student{
private String name ;
private int age ;
private String gender ;
//提供公共 的setXXX()/getXXX()方法
//赋值姓名
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 setGender(String gender){
this.gender = gender ;
}
//获取性别
public String getGender(){
return gender ;
}
//学生学习的成员方法
public void study(String className){
System.out.println("正在学习"+className) ;
}
//抽烟
public void smoke(String smokeBrand){
System.out.println("抽"+smokeBrand) ;
}
}
//测试类
class StudentTest{
public static void main(String[] args){
//创建学生类对象
Student s = new Student() ;
//赋值setXXX
s.setName("马三奇") ;
s.setAge(20) ;
s.setGender("男") ;
System.out.println("学生的姓名是:"+s.getName()+",年龄为:"+s.getAge()+",性别为:"+s.getGender()) ;
s.study("JavaSE之面向对象") ;
s.smoke("小橘") ;
}
}
9、构造方法
构造方法概念:
1)构造方法名和类名一致
2)没有具体的返回值类型
3)连void都没有
构造方法的目的:
为了给类的成员的一些数据进行初始化
构造方法的使用注意事项:
1)当我们书写某个类中代码的时候,没有给这个类提供任何构造方法,那么系统 会默认提供一个无参构造方法
2)如果我们提供了有参构造方法任何一种,那么系统就不会在提供无参构造方法了
建议:永远给出类的无参构造方法
使用代码示例
class Phone{
private String brand ;
private int price ;//价格
private String color ;
public Phone(){
}
//提供了带参数构造方法
//("锤子手机",1299,"黑色"
public Phone(String brand,int price ,String color){//局部变量
this.brand = brand ;
this.price = price ;
this.color = color ;
}
//提供setXXX()/getXXX()方法
public void setBrand(String brand){
this.brand = brand ;
}
public String getBrand(){
return brand ;
}
//给价格赋值
public void setPrice(int price){
this.price = price ;
}
public int getPrice(){
return price ;
}
//给颜色赋值
public void setColor(String color){
this.color = color ;
}
public String getColor(){
return color ;
}
//其他成员方法(手机事物的行为)
}
//测试类
class ConstructorDemo2{
public static void main(String[] args){
//通过无参构造方法创建对象
//方式1:无参构造方法+setXXX()/getXXX()
Phone p = new Phone();//
//setXXX()赋值
p.setBrand("锤子手机") ;
p.setPrice(1299) ;
p.setColor("黑色") ;
System.out.println("品牌:"+p.getBrand()+",价格:"+p.getPrice()+",颜色:"+p.getColor()) ;
System.out.println(p) ;
System.out.println("---------------------") ;
//方式2:通过有参构造方法赋值 + 结合getXXX()获取内容
Phone p2 = new Phone("锤子手机",1299,"黑色") ;
System.out.println("品牌:"+p2.getBrand()+",价格:"+p2.getPrice()+",颜色:"+p2.getColor()) ;
}
}
类的成员方法
成员方法其实就是我们前面讲过的方法
方法具体划分:
根据返回值分为:
有明确返回值方法和返回void类型的方法
根据形式参数分为:
无参方法和带参方法
一个基本类的标准写法
类
成员变量
构造方法
无参构造方法
带参构造方法
成员方法
getXxx()
setXxx()
给成员变量赋值的方式
无参构造方法+setXxx()
带参构造方法