Java上（2024尚硅谷）
day01.[环境变量,HelloWorld]
1.会常用的dos命令
2.会安装java所需要的环境(jdk)
3.会配置java的环境变量
4.知道java开发三步骤
5.会java的入门程序(HelloWorld)
6.会三种注释方式
7.知道Java入门程序所需要注意的地方
8.知道println和print的区别
第一章 Java概述
1.1 JavaSE课程体系介绍
-
第一部分：计算机编程语言核心结构：
数据类型、运算符、流程控制、数组、… -
第二部分：Java面向对象核心逻辑：
类和对象、封装、继承、多态、抽象、接口、… -
第三部分：JavaSE核心高级应用：
集合、I/O、多线程、网络编程、反射机制、… -
第四部分：Java新特性：
Lambda表达式、函数式编程、新Date/Time API、接口的默认、静态和私有方法、… -
第五部分：MySQL/JDBC核心技术：
SQL语句、数据库连接池、DBUtils、事务管理、批处理、…
1.2 计算机语言介绍（了解）
计算机编程语言是什么
所谓计算机编程语言，就是人们使用编程语言对计算机下达的命令，让计算机完成人们需要的功能。
翻译:所谓的计算机编程语言,就是计算机能看懂的语言,我们需要学习这些计算机编程语言,给计算机下达指令,让计算机给我们完成一些功能
计算机语言发展
-
第一代：机器语言(计算机很庞大,都是0和1组成的指令,而且需要同时按下多个键才能完成一个指令,而且用0和1组成的一个一个指令,所以工程师们就要记住0和1的各种组合以及对应的指令)
-
第二代：汇编语言(面向机器的语言,因为直接面对机器需要记一些 0 和1 的指令,很痛苦,所以就出现了很多助记词,比如:add.汇编语言现在还在使用,接近于机器语言,越接近机器语言,速度越快,而且最终还是转成0和1存储)
-
第三代：高级语言(更接近我们人类语言,常见的有很多,比如C语言,java等)
不管是第几代语言,最终都会向0和1靠近,因为CPU只认识0和1 电脑上所有的内容,都是通过CPU将0和1转换而来的
1.3 Java语言概述（了解）
Java生态圈
**Java是目前应用最为广泛的软件开发平台之一。**随着Java以及Java社区的不断壮大，Java 也早已不再是简简单单的一门计算机语言了，它更是一个平台、一种文化、一个社区。
**作为一个平台，**Java虚拟机扮演着举足轻重的作用。除了 Java语言，任何一种能够被编译成字节码的计算机语言都属于Java这个平台。Groovy、Scala、 JRuby、Kotlin等都是Java平台的一部分，它们依赖于Java虚拟机，同时，Java平台也因为它们变得更加丰富多彩。而且Java还可以跨平台
**作为一种文化，**Java几乎成为了 “开源”的代名词。在Java程序中，有着数不清的开源软件和框架。如Tomcat、Struts, Hibernate, Spring,MyBatis等。就连JDK和JVM自身也有不少开源的实现，如OpenJDK、Apache Harmony。可以说，“共享”的精神在Java世界里体现得淋漓尽致。
**作为一个社区，**Java拥有全世界最多的技术拥护者和开源社区支持，有数不清的论坛和资料。从桌面应用软件、嵌入式开发到企业级应用、后台服务器、中间件，都可以看到Java的身影。其应用形式之复杂、参与人数之众多也令人咋舌。可以说，Java社区已经俨然成为了一个良好而庞大的生态系统。其实这才是Java最大的优势和财富。
Java 是最好的语言吗？
不是，因为在每个领域都有更合适的编程语言。
-
C 语言无疑是现代计算机软件编程语言的王者，几乎所有的操作系统都是 C 语言写成的。C里面有一个编译器,会将系统软件变成机器语言,让硬件识别,和硬件做交互.C++ 是面向对象的 C 语言，一直在不断的改进。
-
JavaScript 是能运行在浏览器中的语言，丰富的前端界面离不开 Javascript 的功劳。近年来的 Node.js 又在后端占有一席之地。
-
Python 用于系统管理，并通过高性能预编译的库，提供 API 来进行科学计算，文本处理等，是 Linux 必选的解释性语言。现在Python也被用于web开发、科学计算和统计、人工智能、网络爬虫等
-
Ruby 强于 DSL（领域特定语言），程序员可以定义丰富的语义来充分表达自己的思想。
-
Erlang 就是为分布式计算设计的，能保证在大规模并发访问的情况下，保持强壮和稳定性。
-
Go 语言内置了并发能力，可以编译成本地代码。当前新的网络相关项目，很大比例是由 Go 语言编写的，如 Docker、Kubernetes 等。
-
编写网页用 PHP，函数式编程有 Lisp，编写 iOS 程序有 Swift/Objective-C。
-
R的思想是：它可以提供一些集成的统计工具，但更大量的是它提供各种数学计算、统计计算的函数，从而使使用者能灵活机动的进行数据分析，甚至创造出符合需要的新的统计计算方法
-
SQL 是用于访问和处理数据库的标准的计算机语言， 这类数据库包括：MySQL，Oracle, Sybase, SQL Server, DB2, Access 等等
一句话概括，能留在排行榜之上的语言，都是好的语言，在其所在的领域能做到最好。
Java语言发展历史
Java诞生于SUN（Stanford University Network），09年SUN被Oracle（甲骨文）收购。
Java之父是詹姆斯.高斯林(James Gosling)。
詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言，应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展，Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。
1996年发布JDK1.0版。
目前最新的版本是Java17。我们学习的Java8以及jdk17。
| 发行版本 | 发行时间 | 备注 |
|---|---|---|
| Java | 1995.05.23 | Sun公司在Sun world会议上正式发布Java和HotJava浏览器 |
| Java 1.0 | 1996.01.23 | Sun公司发布了Java的第一个开发工具包 |
| Java 1.1 | 1997.02.19 | |
| Java 1.2 | 1998.12.08 | 拆分成：J2SE（标准版）、J2EE（企业版）、J2ME（小型版） |
| Java 1.3 | 2000.05.08 | |
| Java1.4 | 2004.02.06 | |
| Java 5.0 | 2004.09.30 | ①版本号从1.4直接更新至5.0；②平台更名为JavaSE、JavaEE、JavaME |
| Java 6.0 | 2006.12.11 | 2009.04.20 Oracle宣布收购SUN公司 |
| Java 7.0 | 2011.07.02 | |
| Java 8.0 | 2014.03.18 | |
| Java 9.0 | 2017.09.22 | ①每半年更新一次；②Java 9.0开始不再支持windows 32位系统 |
| Java 10.0 | 2018.03.21 | |
| Java 11.0 | 2018.09.25 | JDK安装包取消独立JRE安装包，长期支持版本 |
| Java 12.0 | 2019.03.19 | |
| Java 13.0 | 2019.9.18 | |
| Java 14.0 | 2020.3.17 |
Google和Oracle的侵权事件:
Google 和 Oracle 纠缠多年的“Java 侵权案”又有了新的判决结果。Google 在此次对决中败诉，并可能需要支付高达88亿美元的赔偿金。这个案件还引发关于 API（应用程序编程接口）是否应该受版权保护的争议。
其实早在2010年8月，Oracle 就已经向法院起诉 Google 侵权，声称 Google 在开发 Android 平台时未经授权就使用了 Oracle 的 Java 应用编程接口数据包。
另外，虽然 Google 当年为避免版权问题而重写了 Java API，却意外地使用了和 Oracle JDK 相同的一小段代码，这使得 Google 陷入不利的局面。
正是由于 Google 在 Android 平台上使用 Java 时并未和 Sun 公司达成授权协议，造成了巨大的隐患，尤其是在 Oracle 收购 Sun 公司之后。
Java技术体系平台
- JavaSE（Java Platform, Standard Edition标准版）：允许您在桌面和服务器上开发和部署Java应用程序。Java提供了丰富的用户界面、性能、多功能性、可移植性和当今应用程序所需的安全性。
- JavaEE（Java Platform, Enterprise Edition企业版）：是为开发企业环境下的应用程序提供的一套解决方案，主要针对于Web应用程序开发。
- JavaME（Java Platform, Micro Edition 小型版）：为互联网上的嵌入式和移动设备上运行的应用提供了一个健壮、灵活的环境：微控制器、传感器、网关、移动电话、个人数字助理（PDA）、电视机顶盒、打印机等等。JavaME包括灵活的用户界面、健壮的安全性、内置的网络协议，以及支持动态下载的网络和离线应用程序。基于JavaME的应用程序在许多设备上都是可移植的，但是利用了每个设备的本机功能。
- Java Embedded(Im’bedId): 用于解锁物联网的智能设备的价值：
通过远程市场更新和刷新功能延长产品生命周期和价值；
利用Java的可伸缩性、健壮性、可移植性和全套功能，提高生产效率，降低成本，缩短上市时间；
在边缘启用快速数据功能； - Java Card：使安全元件（如智能卡和其他防篡改安全芯片）能够承载采用Java技术的应用程序。Java card提供了一个安全的、可互操作的执行平台，它可以在一个资源受限的设备上存储和更新多个应用程序，同时保持最高的认证级别和与标准的兼容性。
- Java TV：是一种基于JavaME的技术，它为开发在tv和机顶盒设备上运行的java应用程序提供了一个性能良好、安全且易于实现的解决方案。使用Java TV运行时，开发人员可以轻松创建应用程序，例如电子节目指南（EPG）、视频点播（VOD）客户端、游戏和教育应用程序、用于访问Internet数据的应用程序（例如天气、新闻播报器、社交网络）以及大多数蓝光光盘标题上的用户界面和奖金内容。
- Java Embedded(Im’bedId): 用于解锁物联网的智能设备的价值：
1.4 什么是软件开发
1.概述:
软件开发是根据用户要求建造出软件系统或者系统中的软件部分的过程
软件开发是一项包括需求捕捉、需求分析、设计、实现和测试的系统工程
软件一般是用某种程序设计语言来实现的。通常采用软件开发工具可以进行开发
2.我们将来主要从事软件开发中各个环节的哪个环节呢?实现
3.我们将来主要用什么程序设计语言来开发呢? java语言 sql语言 js
第二章.Java语言前言
1.字节
1.字节:计算机中存储数据的最小存储单元(计量单位),用byte或者B表示
二进制位:用bit(比特)表示
8个二进制位代表一个字节
2.存储单元之间的转换:
8bit = 1B
1024B = 1KB
1024KB = 1MB
1024MB = 1GB
1024GB = 1TB
PB EB ZB ...
2.常用的dos命令
1.打开dos命令窗口:
win+r -> 输入cmd -> 回车
| 作用 | 命令 |
|---|---|
| 切换盘符 | 盘符名: -> 回车 盘符名不区分大小写,但是计算机上必须有指定的盘符 |
| 查看当前路径下的文件或者文件夹 | dir |
| 进入到指定文件夹下 | cd 文件夹名字 |
| 进入到多级文件夹下 | cd 文件夹名字\文件夹名字 |
| 退到上一级目录 | cd…或者 cd … |
| 直接退到磁盘位置(退到根目录) | cd\或者cd \ |
| 清屏 | cls |
| 退出黑窗口 | exit |
| 创建文件夹 | mkdir 文件夹名 |
| 创建多级文件夹 | mkdir 文件夹名\文件夹名 |
| 删除文件夹 | rd 文件夹名 注意:删除的文件夹必须是空的 不走回收站 |
| 删除文件 | del 文件名.后缀名 不走回收站 |
| 批量删除文件 | del *.后缀名 |
1.如何区分正斜杠和反斜杠:
/:正斜杠
:反斜杠
2.快速打开该目录对应的dos命令窗口:
a.选中路径
b.输入cmd -> 回车
3.按上下箭头,切换之前输入过的命令
4.在dos命令窗口中,可以输入文件夹名或者文件名的一部分,按 -> tab键 -> 自动补全文件夹名或者文件名
第三章.Java所需要的环境
1.jvm和跨平台
1.jvm(java虚拟机):java运行程序的假想计算机,主要用来运行java程序的
2.跨平台:java代码可以在不同的操作系统上运行(一次编写,到处运行)
跨:跨越
平台:操作系统 -> windows linux mac os
3.关系:java程序想要在不同的操作系统上运行,实现跨平台,就需要安装不同版本的jvm
2.JDK和JRE
1.jdk:(Java Development Kit):java开发工具包,包含了jre
javac 编译工具
java 运行工具
jdb 调试工具
jhat 内存分析工具
...
2.jre:(Java Runtime Environment):java运行环境,包含了jvm以及后面开发用到的核心类库
3.jdk和jre以及jvm的关系:
jdk包含了jre,jre包含了jvm,所以我们只需要安装jdk即可
但是从jdk9开始jdk目录中就没有单独的jre目录了,因为jre作为一个运行时,里面不需要包含太多的东西浪费空间,降低运行效率,在jdk9的时候引用模块化的技术,让开发者能按照自己的应用创建一个最小的运行时(比如一个微服务的部署应用仅仅需要一个非常小的runtime,而不是像以前一样不管应用复杂还是简单,都需要一个近百兆的jre运行)这样提高了运行效率
2.1.jdk安装
1.下载:www.oracle.com
1.安装:双击 -> 选择安装路径(安装路径上不要有中文,不要有空格)
2.一定要记住:以后所有开发相关的安装路径上都不要有中文和空格
测试:进入到jdk的bin路径下,打开对应dos命令窗口
输入javac(编译命令)和java(运行命令)
2.2.环境变量的配置
1.问题:将来我们需要创建一个java文件写代码,然后编译和运行的时候需要打开此java文件所在的目录,java文件的目录如果和javac以及java命令所在的bin目录不一致,那么javac和java命令就用不了了,毕竟javac和java命令在bin目录下,所以难道我们将来必须将所有的java文件都放到bin目录下吗?
那么我们能不能在任意目录下都能使用javac和java命令呢?能,需要配置环境变量
2.配置环境变量的目的:在任意路径下都可以随意使用javac和java命令进行对java代码的编译和运行
方式1:直接将jdk的bin路径粘贴到path中 -> 不推荐
方式2:极力推荐
配置JAVA_HOME
jdk安装之后,自带环境变量配置->javapath(可以删除)->推荐使用JAVA_HOME
可能出现的问题:电脑重启之后,环境变量失效了
1.解决问题1:点到环境变量中,啥都不要做,直接点一下确定
2.解决问题2:直接将bin路径粘进去
当然,后面学了idea之后,不会出现这种问题了
第四章.Java第一个程序的开发
1.开发三步骤
1.编写:
a.创建一个文本文档,将后缀名改成.java,变成一个java文件
b.注意:我们需要将文件的后缀名显示出来
2.编译:
a.命令:javac java文件名.java
b.注意:javac会将java文件编译,生成一个.class文件(字节码文件),jvm运行只认class文件
3.运行:
a.命令:java class文件名(不需要带后缀名了)
2.编写HelloWorld
public class Demo01HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld");
}
}
编译:
javac java文件名.java
运行:
java class文件名(不要带后缀名了)
3.注释
1.概述:对代码的解释说明
2.分类:
a.单行注释:
//注释内容
b.多行注释:
/*
注释内容
*/
c.文档注释:
/**
注释内容
*/
//单行注释 class后面的名字要和java文件名一致
public class Demo01HelloWorld{
/*
多行注释:
main是一个方法,是程序的入口,jvm运行程序要找main当入口
执行程序
*/
public static void main(String[] args){
/**
文档注释:
下面的语句是输出语句
*/
System.out.println("HelloWorld");
}
}
1.文档注释作用:将来我们给别人一个开发好的类,如何让别人快速对我们写的代码了解呢?
我们的文档注释中的内容可以根据javadoc命令生成一个文档(API文档)
别人拿到这个文档,就能快速对此类以及类中实现的功能,进行快速了解
2.命令:javadoc -d 要生成的文件夹名字 -author -version 文件名.java
/**
此类是一个java的入门程序
@author 涛哥
@version v1.0
*/
public class Demo02HelloWorld{
/**
main是一个方法,是程序的入口
jvm执行java代码,都是从main方法开始执行
*/
public static void main(String[] args){
System.out.println("helloworld");
}
}
1.右键中没有创建文件或者文件夹的选项 -> 所在的磁盘有权限问题
2.右键盘符 -> 属性 -> 安全 -> 编辑 -> 修改权限(完全控制)
4.第一个Java程序中每一句话的解释以及注意事项
/*
1.public class Demo03HelloWorld:定义一个类
2.class:代表的就是类,类是java程序最基本的组成单元,所有代码都需要在类中写
3.class后面跟的名字叫做类名,类名要和java文件名保持一致
*/
public class Demo03HelloWorld{
/*
public static void main(String[] args)
叫做main方法,是程序的入口
jvm执行代码,会从main方法开始执行
*/
public static void main(String[] args){
//打印语句(输出语句),会将我们想要输出的内容打印到控制台上
System.out.println("helloworld");
}
}
注意事项:
1.类名要和java文件名保持一致
2.程序中的标点符号必须是英文的
3.不要将main写成mian
4.System和String的首字母s要大写
5.每个单词写完来个空格增强代码的可读性
6.括号要一对一对的写
7.代码写完语句用;代表结束了,一句话来个分号,证明这是一个单独的语句
6.关键字
1.关键字:java提前定义好的,具有特殊含义的小写单词
2.怎么记:不用提前都背下来,关键字在高级记事本中颜色特殊,学到哪里记到哪里
Java关键字大全
7.编写HelloWorld时要注意的问题
7.1字符编码问题
1.编码:保存数据的过程就是编码的过程
2.解码:读数据的过程就是解码的过程
3.注意:
a.编码和解码遵守的编码规范必须是一样的
b.常见的两个编码规范:
GBK:专门为我们中文所设计的编码
ANSI代表的是GBK
一个中文汉字在GBK中占2个字节
UTF-8:一个中文汉字在UTF-8中占3个字节
c.dos命令窗口默认编码:GBK
7.2源文件名(java文件名)与类名一致问题？
1.类名必须要和java文件名一致嘛?
不是必须的
如果类名和java文件名不一致,需要将class前面的public干掉
2.如果class前面带public,此时类名必须要和java文件名一致
3.一个java文件中可以写多个class类,但是只能有一个类带public
但是建议不要随意在一个java文件中写多个class -> 一个java文件中就写一个class,而且带public的
4.main方法必须写在带public的类中
小结:
1.一个java文件只写一个class,而且带public
2.类名和java文件名保持一致
3.main方法写在带public的类中
9.println和print区别
相同点:都是输出语句
不同点:
a.println:输出之后自带换行效果
b.print:输出之后不带换行效果
public class Demo05HelloWorld{
public static void main(String[] args){
//System.out.println("床前明月光");
//System.out.println("疑是地上霜");
//System.out.println("举头望明月");
//System.out.println("低头思故乡");
System.out.print("床前明月光");
System.out.print("疑是地上霜");
System.out.print("举头望明月");
System.out.print("低头思故乡");
}
}
小技巧:
1.复制当前行:ctrl+d
2.一次操作多行:
a.预留出足够的空间
b.按住alt不放,鼠标往下拉,此时发现光标变长了
模块二.变量 数据类型转换 运算符
第一章.常量
1.概述:在代码的运行过程中,值不会发生改变的数据
2.分类:
整数常量:所有整数
小数常量:所有带小数点的
2.5 1.5 2.0
字符常量:带单引号的 '' 单引号中必须有且只能有一个内容
'1'(算) '11'(不算) ''(不算) 'a1'(不算)
' '(算) ' '(两个空格不算)
'写一个tab键'(算)
字符串常量:带双引号的 "" 双引号中内容随意
"" "helloworld"
布尔常量:true(真) false(假) -> 这两个单词不要加双引号
"true"(这样写属于字符串,不属于布尔常量)
空常量:null 代表的是数据不存在
public class Demo01Constant{
public static void main(String[] args){
//整数常量
System.out.println(1);
System.out.println(-1);
//小数常量
System.out.println(1.5);
System.out.println(1.0);
//字符常量 单引号中必须有且只能有一个内容
System.out.println('1');
//System.out.println('11');错误
System.out.println(' ');//一个空格算一个内容
//System.out.println(' ');//四个空格算四个内容,所以不属于字符常量
System.out.println(' ');//tab键算一个内容
//字符串常量
System.out.println("本人是尚硅谷第一帅的男人");
System.out.println("");
//布尔常量
System.out.println(true);
System.out.println(false);
//空常量 不能直接使用
//System.out.println(null);
}
}
public class Demo02Constant{
public static void main(String[] args){
System.out.println(10+3);//13
System.out.println(10-3);//7
System.out.println(10*3);//30
/*
/前后如果都是整数,结果只取整数部分
/前后只要有一个数带小数点,结果就是正常小数了
*/
System.out.println(10/3);//3
System.out.println(10.0/3);//3.3333333333333335
System.out.println(10/3.0);//3.3333333333333335
}
}
第二章.变量
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
|---|---|---|---|
| 字节型 | byte | 1个字节 | -128 至 127 定义byte变量时超出范围,废了 |
| 短整型 | short | 2个字节 | -32768 至 32767 |
| 整型 | int（默认） | 4个字节 | -231 至 231-1 正负21个亿 -2147483648——2147483647 |
| 长整型 | long | 8个字节 | -263 至 263-1 19位数字 -9223372036854775808到9223372036854775807 |
| 单精度浮点数 | float | 4个字节 | 1.4013E-45 至 3.4028E+38 |
| 双精度浮点数 | double（默认） | 8个字节 | 4.9E-324 至 1.7977E+308 |
| 字符型 | char | 2个字节 | 0 至 216-1 |
| 布尔类型 | boolean | 1个字节 | true，false(可以做判断条件使用) |
1.变量的介绍以及使用
1.变量的数据类型:
基本数据类型:4类8种
整型:byte short int long
浮点型:float double
字符型:char
布尔型:boolean
引用数据类型: 类 数组 接口 枚举 注解
2.概述:在代码的运行过程中,值会随着不同的情况而随时发生改变的数据
3.作用:一次接收一个数据
将来定义一个变量,接收一个值,后续可能会根据不同的情况对此值进行修改,此时可以用变量
4.定义:
a.数据类型 变量名 = 值;
b.数据类型 变量名;
变量名 = 值;
c.连续定义三个相同类型的变量
数据类型 变量名1,变量名2,变量名3;
变量名1 = 值;
变量名2 = 值;
变量名3 = 值;
比如:int i,j,k;
i = 10;
j = 20;
k = 30;
数据类型 变量名1 = 值,变量名2 = 值,变量名3 = 值;
比如: int i = 10,j = 20,k = 30;
正确读法:先看等号右边的,再看等号左边的 -> 将等号右边的数据赋值给等号左边的变量
哪怕等号右边有运算,我们都得先将等号右边的运算算出一个值来,最后赋值给等号左边的变量
5.注意:
a.字符串不属于基本数据类型,属于引用数据类型,用String表示
String（引用数据类型）是一个类,只不过字符串在定义的时候可以和基本数据类型格式一样
6.float和double的区别:
a.float的小数位只有23位二进制,能表示的最大十进制为2的23次方(8388608),是7位数,所以float型代表的小数,小数位能表示7位
b.double的小数位只有52位二进制,能表示的最大十进制为(4 503 599 627 370 496),是16位数,所以double型代表的小数,小数位能表示出16位
7.切记:将来开发不要用float或者double直接参与运算,因为直接参与运算会有精度损失问题
public class Demo03Var{
public static void main(String[] args){
//byte
byte num1 = 100;
System.out.println(num1);
//short
short num2 = 1000;
num2 = 1001;
System.out.println(num2);
//int 整数的默认类型
int num3 = 10000;
num3 = 1;
System.out.println(num3);
//long -> 定义long型的变量后面加个L
long num4 = 10L;
System.out.println(num4);
//float -> 定义float型变量的时候后面加个F
float num5 = 2.5F;
System.out.println(num5);
//double -> 小数的默认类型
double num6 = 2.5;
System.out.println(num6);
//char
char num7 = 'A';
System.out.println(num7);
//boolean
boolean num8 = true;
boolean num9 = false;
/*
num9 = false
num8 = num9 -> 将num9的值赋值给num8 -> 相当于num8 = false
*/
num8 = num9;
System.out.println(num8);
//String -> 是一个引用数据类型,属于类的一种,但是定义和基本类型一致
String name = "金莲";
System.out.println(name);
}
}
public class Demo04Var{
public static void main(String[] args){
int num1 = 10;
int num2 = 3;
int sum = num1+num2;
System.out.println(sum);//13
int sub = num1-num2;
System.out.println(sub);//7
//System.out.println(num1*num2);//30
int mul = num1*num2;
System.out.println(mul);//30
/*
由于/前后都是整数,结果取整数部分,结果还赋值给一个整数变量
*/
int div = num1/num2;
System.out.println(div);//3
double div1 = num1/num2;//3.0
System.out.println(div1);
}
}
public class Demo05Var{
public static void main(String[] args){
/*
转义字符: \
可以这样简单理解:
a.将普通字符转成具有特殊含义的字符
b.将具有特殊含义的字符转成普通字符
*/
/*
n:普通字符
\n:换行符
*/
System.out.print("春眠不觉晓\n");
System.out.print("处处闻啼鸟\n");
System.out.print("夜来风雨声\n");
System.out.print("花落知多少\n");
/*
t:普通字符
\t:制表符 -> 就是tab键
*/
System.out.println("本人\t是尚硅谷第一帅");
/*
用String表示一个路径
在java中两个\\代表一个\
*/
String path = "E:\\01_javase_video\\code";
System.out.println(path);
}
}
public class Demo06Var{
public static void main(String[] args){
float a = 10;
float b = 3;
float result = a/b;
System.out.println(result);//3.3333333
double c = 10;
double d = 3;
double result02 = c/d;
System.out.println(result02);//3.3333333333333335
float x = 3.55F;
float y = 2.12F;
float result03 = x-y;
System.out.println(result03);//1.4300001
}
}
2.变量使用时的注意事项
1.变量不初始化(第一次赋值)不能直接使用
2.在同一个作用域(一对大括号就是一个作用域)中不能定义重名的变量
3.不同作用域中的数据尽量不要随意互相访问
在小作用域中能直接访问大作用域中的变量
在大作用域中不能直接访问小作用域中的变量
public class Demo07Var{
public static void main(String[] args){
int i = 10;
System.out.println(i);
int j;
j = 10;
System.out.println(j);
int k = 10;
//int k = 20;//只要是变量名前带具体的数据类型就是重新定义
System.out.println(k);
{
int x = 1000;
System.out.println(k);
}
//System.out.println(x);
}
}
3.练习
定义一个人类,用变量表示 姓名 性别 年龄 身高 体重
public class Demo08VarPerson{
public static void main(String[] args){
//姓名
String name = "张三";
//性别
char sex = '男';
//年龄
int age = 20;
//身高
double height = 175.5;
//体重
double weight = 145.5;
System.out.println(name);
System.out.println(sex);
System.out.println(age);
System.out.println(height);
System.out.println(weight);
}
}
第三章.标识符
1.概述:咱们给类,方法,变量取的名字
2.注意:
a.硬性规定(必须遵守)
标识符可以包含"英文字母","数字","$和_"
标识符不能以数字开头 int i1 = 100(正确) int 1i = 100(错误)
标识符不能是关键字 int static = 100(错误) int public = 100(错误)
b.软性建议(可遵守可不遵守,但是建议遵守)
给类取名字:遵循大驼峰式 -> 每个单词首字母大写
给方法和变量取名字:遵循小驼峰式 -> 从第二个单词开始往后首字母大写
见名知意
第四章.数据类型转换
1.什么时候发生类型转换:
a.等号左右两边类型不一致
b.不同类型的数据做运算
2.分类:
a.自动类型转换
将取值范围小的数据类型赋值给取值范围大的数据类型 -> 小自动转大
取值范围小的数据类型和取值范围大的数据类型数据做运算 -> 小自动转大
b.强制类型转换
当将取值范围大的数据类型赋值给取值范围小的数据类型 -> 需要强转
3.基本类型中按照取值范围从小到大排序:
byte,short,char -> int -> long -> float -> double
1.自动类型转换
1.将取值范围小的数据类型赋值给取值范围大的数据类型 -> 小自动转大
2.取值范围小的数据类型和取值范围大的数据类型做运算 -> 小自动转大
public class Demo09DataType{
public static void main(String[] args){
/*
等号右边是整数,整数默认类型为int
等号左边是long型的变量
将取值范围小的数据类型赋值给取值范围大的数据类型,发生了自动类型转换
*/
long num1 = 100;
System.out.println(num1);
int i = 10;
double b = 2.5;
/*
double = int+double
double = double+double
int自动提升为了double,发生了自动类型转换
*/
double sum = i+b;
System.out.println(sum);
}
}
2.强制类型转换
1.将取值范围大的数据类型赋值给取值范围小的数据类型
取值范围小的数据类型 变量名 = 取值范围大的数据类型 -> 需要强转
2.怎么强转:
取值范围小的数据类型 变量名 = (取值范围小的数据类型)取值范围大的数据类型
public class Demo10DataType{
public static void main(String[] args){
/*
等号右边的数据是小数,小数默认类型为double
等号左边的变量是float型
将取值范围大的赋值给取值范围小 -> 报错,需要强转
*/
//float num1 = 2.5;
//float num1 = (float)2.5;
float num1 = 2.5F;
System.out.println(num1);
}
}
3.强转的注意事项
1.不要随意写成强转的格式,因为会有精度损失问题以及数据溢出现象,除非没有办法
2.byte,short定义的时候如果等号右边是整数常量,如果不超出byte和short的范围,不需要我们自己强转,jvm自动转型
byte,short如果等号右边有变量参与,byte和short自动提升为int,然后结果再次赋值给byte或者short的变量,需要我们自己手动强转
3.char类型数据如果参与运算,会自动提升为int型,如果char类型的字符提升为int型会去ASCII码表(美国标准交换代码)范围内去查询字符对应的int值,如果在ASCII码表范围内没有对应的int值,回去unicode码表(万国码)中找
public class Demo11DataType{
public static void main(String[] args){
//精度损失
int i = (int)2.9;
System.out.println(i);
/*
数据溢出
int型占内存4个字节,4个字节变成二进制是32位
100个亿: 10 0101 0100 0000 1011 1110 0100 0000 0000 -> 34位二进制
100个亿的二进制位比int型的二进制位多出来2位,此时干掉最前面的2位
101 0100 0000 1011 1110 0100 0000 0000
101 0100 0000 1011 1110 0100 0000 0000->1410065408
*/
int j = (int)10000000000L;
System.out.println(j);//1410065408
System.out.println("=========================");
byte b = 10;
System.out.println(b);
b = (byte)(b+1);
System.out.println(b);
System.out.println("=========================");
char c = '中';
System.out.println(c+0);//20013
}
}
第五章.进制的转换(了解)
| 十进制 | 二进制 | 八进制 | 十六进制 |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 2 | 10 | 2 | 2 |
| 3 | 11 | 3 | 3 |
| 4 | 100 | 4 | 4 |
| 5 | 101 | 5 | 5 |
| 6 | 110 | 6 | 6 |
| 7 | 111 | 7 | 7 |
| 8 | 1000 | 10 | 8 |
| 9 | 1001 | 11 | 9 |
| 10 | 1010 | 12 | a或A |
| 11 | 1011 | 13 | b或B |
| 12 | 1100 | 14 | c或C |
| 13 | 1101 | 15 | d或D |
| 14 | 1110 | 16 | e或E |
| 15 | 1111 | 17 | f或F |
| 16 | 10000 | 20 | 10 |
3.1 十进制转成二进制
辗转相除法 -> 循环除以2,取余数
3.2 二进制转成十进制
8421规则
3.3 二进制转成八进制
将二进制数分开 (3位为一组)
3.4 二进制转成十六进制
将二进制数分组-> 4位为一组
第六章.位运算符(了解)
1.符号的介绍:
a. &(与) -> 有假则假
b. |(或) -> 有真则真
c. ~(非) -> 取反
d. ^(异或) -> 符号前后结果一样为false,不一样为true
true ^ true -> false
false ^ false -> false
true ^ false -> true
false ^ true -> true
2. 1代表true 0代表false
3.我们要知道计算机在存储数据的时候都是存储的数据的补码,计算也是用的数据的补码
但是我们最终看到的结果是原码换算出来的
原码 反码 补码
4.正数二进制最高位为0; 负数二进制最高位为1
5.如果是正数 原码 反码 补码 一致
比如:5的原码 反码 补码一致:
0000 0000 0000 0000 0000 0000 0000 0101 -> 因为是正数,二进制最高位为0
如果是负数,原码 反码 补码不一样了
反码是原码的基础上最高位不变,剩下的0和1互换
补码是在反码的基础上+1
比如:-9
原码: 1000 0000 0000 0000 0000 0000 0000 1001
反码: 1111 1111 1111 1111 1111 1111 1111 0110
补码: 1111 1111 1111 1111 1111 1111 1111 0111
（1）左移：<<
运算规则：左移几位就相当于乘以2的几次方
**注意：**当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位
2<<2 结果等于8
快速算法: 2*(2的2次方)
-2<<2 等于-8
快速算法: -2*(2的2次方)
（2）右移：>>
快速运算：类似于除以2的n次，如果不能整除，向下取整
9>>2 等于2
快速算法: 9除以(2的2次方)
-9>>2 等于-3
快速算法: -9除以(2的2次方)
（3）无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补0，不管最高位是0还是1空出来的都拿0补
正数：和右移一样
9>>>2 等于2
负数：右边移出去几位，左边补几个0，结果变为正数
-9>>>2
结果为:1073741821
笔试题: 8>>>32位 -> 相当于没有移动还是8
8>>>34位 -> 相当于往右移动2位
（4）按位与：&
小技巧:将0看成为false 将1看成true
运算规则：对应位都是1才为1,相当于符号左右两边都为true,结果才为true
1&1 结果为1
1&0 结果为0
0&1 结果为0
0&0 结果为0
5&3 结果1
（5）按位或：|
运算规则：对应位只要有1即为1,相当于符号前后只要有一个为true,结果就是true
1|1 结果1
1|0 结果1
0|1 结果1
0|0 结果0
5|3 结果为7
（6）按位异或：^
运算规则：对应位一样的为0,不一样的为1
1^1 结果为0 false
1^0 结果为1 true
0^1 结果为1 true
0^0 结果0 false
5^3 结果为6
（7）按位取反
运算规则：~0就是1
~1就是0
~10 结果为-11
第七章.运算符的优先级(了解)
提示说明：
（1）表达式不要太复杂
（2）先算的使用(),记住,如果想让那个表达式先运行,就加小括号就可以了
i<(n*m)
模块三 idea_运算符
第一章.IDEA的使用
1.idea的介绍
1.概述:开发工具
2.特点:
a.idea是java写的,所以本地上必须有正确的jdk环境(JAVA_HOME)
b.idea自动保存
c.不用我们打开dos命令窗口执行javac和java命令
d.idea有强大的快捷键,生成代码,纠错等
e.idea会自动管理我们写的代码
3.相关开发工具:eclipse myeclipse
4.作用:加速我们的开发
2.idea的目录结构
先创建project,在project下创建module,在module下创建package -> 必须记住
3.Project的操作
3.1.project的创建
3.2再次创建一个新的Project
3.3.关闭Project
file-> close project
3.4.打开project
4.module的操作
4.1.创建module
4.2.关闭module
a.对着要关闭的module右键 -> remove module -> 此时是关闭,不是真正的删除module
b.再对着关闭的module右键-> delete -> 从本地上真正删除
4.3.导入已有的module
5.package的操作
5.1创建
5.2 package的删除
右键-> delete
5.3 package取名字规范
1.公司域名倒着写:
比如:尚硅谷 域名为:www.atguigu.com
我们写代码创建包: com.atguigu
6.创建类以及基本语句生成快捷键
1.生成main方法:输入main -> 回车
2.生成输出语句:sout -> 回车
3.将变量名放到输出语句中:
a.变量名.sout
b.变量名.soutv -> 带字符串平拼接格式的输出方式-> 输出格式好看
7.基本设置
7.1设置字体
file-settings
7.2设置提示的快捷键
file-settings
7.3 设置注释字体
8.快捷键
| 快捷键 | 功能 |
|---|---|
Alt+Enter |
导入包，自动修正代码(重中之重) |
Ctrl+Y |
删除光标所在行 |
Ctrl+D |
复制光标所在行的内容，插入光标位置下面 |
Ctrl+Alt+L |
格式化代码 |
Ctrl+/ |
单行注释 |
Ctrl+Shift+/ |
选中代码注释，多行注释，再按取消注释 |
Alt+Shift+上下箭头 |
移动当前代码行 |
先写等号右边的,可以自动生成等号左边的变量
或者
9.出现的问题
1.在运行代码时会出现"找不到对应的发行源"或者"不支持发行版本"或者"无效的发行源版本",证明本地jdk版本和idea中的language level不匹配
所以要匹配版本
file->project Structure->点击project->引入本地jdk->project level选择对应的版本
2.没有out路径的问题
out路径是专门存放idea自动编译生成的.class文件的
所以需要指明out路径
3.src是灰色的,对着src,右键,选项中没有java class或者package
4.刚使用,jdk没有配置
第二章.运算符
1.算数运算符
| 符号 | 说明 |
|---|---|
| + | 加法 |
| - | 减法 |
| * | 乘法 |
| / | 除法 如果符号前后都是整数,结果取整数部分 如果符号前后有一个为小数,结果就是正常小数 |
| % | 模,取余数部分 |
public class Demo01Arithmetic {
public static void main(String[] args) {
int i = 10;
int j = 3;
int add = i+j;//推荐使用
System.out.println(add);//13
System.out.println(i+j);//13
int sub = i-j;
System.out.println(sub);//7
int mul = i*j;
System.out.println(mul);//30
int div = i/j;
System.out.println(div);//3
int mo = i%j;
System.out.println(mo);//1
}
}
+:
1.运算
2.字符串拼接:任何类型的数据遇到字符串都会变成字符串,此时+就不再是运算了,而是字符串拼接,将内容直接往后拼接
public class Demo02Arithmetic {
public static void main(String[] args) {
int i = 10;
int j = 3;
System.out.println(i+j+"");//13
System.out.println(i+j+""+1);//131
System.out.println(i+""+j);//103
System.out.println("i和j相加只和为:"+(i+j));
}
}
1.2.自增自减运算符(也算算数运算符的一种)
1.格式:
变量++ -> 后自加
++变量 -> 前自加
变量-- -> 后自减
--变量 -> 前自减
自增和自减只变化1
2.使用:
a.单独使用: ++ -- 单独为一句,没有和其他的语句掺和使用
i++;
符号前在在后都是先运算
b.混合使用: ++ -- 和其他的语句掺和使用了(比如:输出语句,赋值语句)
符号在前:先运算,在使用运算后的值
符号在后:先使用原值,使用完毕之后,自身再运算
public class Demo03Arithmetic {
public static void main(String[] args) {
int i = 10;
//i++;
++i;
System.out.println("i = " + i);
System.out.println("==================");
int j = 100;
int result01 = ++j;
System.out.println("result01 = " + result01);//101
System.out.println(j);//101
System.out.println("==================");
int k = 10;
int result02 = k++;
System.out.println("result02 = " + result02);
System.out.println(k);
System.out.println("==================");
int z = 100;
System.out.println(z++);
System.out.println(z);
System.out.println("==================");
int x = 10;
int y = 20;
/*
10+19 = 29
29+12 = 41
以后开发肯定不会这么写
*/
int result03 = x++ + --y + ++x;
System.out.println("result03 = " + result03);
System.out.println("=======================");
int c = 10;
c = c++;
System.out.println(c);//10
System.out.println(c);//10
}
}
c++原理 -> 反编译
3.赋值运算符
1.基本赋值运算符:
= -> 先看等号右边的,再将右边的数据赋值给等号左边的变量
2.复合赋值运算符:
+=:
int i = 10;
i+=2 -> i = i+2
-=
*=
/= : 取整数部分
%= : 取余数部分
3.注意:byte short 遇到复合赋值运算符,jvm会自动转型
public class Demo01Assignment {
public static void main(String[] args) {
int i = 10;
i+=2;//i = i+2
System.out.println(i);
}
}
public class Demo02Assignment {
public static void main(String[] args) {
byte b = 10;
//b = (byte)(b + 1);
b+=1;//b = b+1
System.out.println(b);
}
}
4.关系运算符(比较运算符)
1.结果:boolean型 -> 要么是true,要么是false
2.作用:做条件判断使用
| 符号 | 说明 |
|---|---|
| == | 如果符号前后相等为true;否则为false |
| > | 如果符号前的数据大于符号后的数据为true,否则为false |
| < | 如果符号前的数据小于符号后的数据为true,否则为false |
| >= | 如果符号前的数据大于或者等于符号后的数据为true,否则为false |
| <= | 如果符号前的数据小于或者等于符号后的数据为true,否则为false |
| != | 如果符号前后不相等为true;否则为false |
public class Demo01Compare {
public static void main(String[] args) {
int i = 10;
int j = 20;
boolean result01 = i == j;
System.out.println("result01 = " + result01);//false
System.out.println(i>j);//false
System.out.println(i<j);//true
System.out.println(i>=j);//false
System.out.println(i<=j);//true
System.out.println(i!=j);//true
}
}
5.逻辑运算符
1.作用:连接多个boolean结果的
2.结果:boolean型结果
| 符号 | 说明 |
|---|---|
| &&(与,并且) | 有假则假,符号前后有一个结果为false,整体就是false |
| ||(或者) | 有真则真,符号前后有一个结果为true,整体就是true |
| !(非,取反) | 不是true,就是false;不是false,就是true |
| ^(异或) | 符号前后结果一样为false;不一样为true true^true -> false true^false -> true false^true -> true false^false -> false |
public class Demo01Logic {
public static void main(String[] args) {
int i = 10;
int j = 20;
int k = 10;
boolean result01 = (i>j) && (i==k);
System.out.println("result01 = " + result01);//false
boolean result02 = (i>j) || (i==k);
System.out.println("result02 = " + result02);//true
boolean result03 = (i>j) ^ (i==k);//false ^ true
System.out.println("result03 = " + result03);//true
boolean result04 = !(i>j) ;
System.out.println("result04 = " + result04);//true
}
}
符号 说明 & 1.单与,如果前后都是布尔型,有假则假,但是如果符号前为false,符号后的判断会继续执行
2.如果该符号前后都是数字,看做是位运算符&& 1.双与,有假则假,但是有短路效果,如果符号前为false,符号后的判断就不会执行了 | 1.单或,如果前后都是布尔型,有真则真,但是如果符号前为true,符号后的判断会继续执行
2.如果该符号前后都是数字,看做是位运算符|| 1.双或,有真则真,但是有短路效果,如果符号前为true,符号后的判断就不会执行了 public class Demo02Logic { public static void main(String[] args) { int a = 10; int b = 20; //boolean result01 = (++a>100)&(++b>10); //boolean result01 = (++a > 100) && (++b > 10); //boolean result01 = (++a<100)|(++b>10); boolean result01 = (++a<100)||(++b>10); System.out.println("result01 = " + result01); System.out.println("a = " + a); System.out.println("b = " + b); } }问题:定义一个变量(a),随意给一个值,判断这个变量接收的值是否在1-100之间
1<=a<=100 -> 错误,这是数学写法
i>=1 && i<=100 -> java写法,用逻辑运算符拼接多个判断
6.三元运算符
1.格式:
boolean表达式?表达式1:表达式2
2.执行流程:
先判断,如果是true,就走?后面的表达式1,否则就走:后面的表达式2
模块四_流程控制
第一章.键盘录入_Scanner
1.概述:是java定义好的一个类
2.作用:将数据通过键盘录入的形式放到代码中参与运行
3.位置:java.util
4.使用:
a.导包:通过导包找到要使用的类 -> 导包位置:类上
import java.util.Scanner -> 导入的是哪个包下的哪个类
b.创建对象
Scanner 变量名 = new Scanner(System.in);
c.调用方法,实现键盘录入
变量名.nextInt() 输入整数int型的
变量名.next() 输入字符串 String型的
public class Demo01Scanner {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//录入int型整数
int data1 = sc.nextInt();
System.out.println("data1 = " + data1);
//录入String型字符串
String data2 = sc.next();
System.out.println("data2 = " + data2);
}
}
====================================================
public class Demo02Scanner {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//录入int型整数
int old1 = sc.nextInt();
int old2 = sc.nextInt();
int old3 = sc.nextInt();
int temp = old1>old2?old1:old2;
int max = temp>old3?temp:old3;
System.out.println(max);
}
}
变量名.next():录入字符串 -> 遇到空格和回车就结束录入了 变量名.nextLine():录入字符串 -> 遇到回车就结束录入了public class Demo03Scanner { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String data1 = sc.next(); String data2 = sc.nextLine(); System.out.println(data1); System.out.println(data2); } }Exception in thread "main" java.util.InputMismatchException -> 输入类型不匹配异常 at java.base/java.util.Scanner.throwFor(Scanner.java:939) at java.base/java.util.Scanner.next(Scanner.java:1594) at java.base/java.util.Scanner.nextInt(Scanner.java:2258) at java.base/java.util.Scanner.nextInt(Scanner.java:2212) at com.atguigu.a_scanner.Demo04Scanner.main(Demo04Scanner.java:8) 原因:录入的数据和要求的数据类型不一致
第二章.Random随机数
学习Random和学习Scanner方式方法一样
1.概述:java自带的一个类
2.作用:可以在指定的范围内随机一个整数
3.位置:java.util
4.使用:
a.导包:import java.util.Random
b.创建对象:
Random 变量名 = new Random()
c.调用方法,生成随机数:
变量名.nextInt() -> 在int的取值范围内随机一个整数
public class Demo01Random {
public static void main(String[] args) {
//创建对象
Random rd = new Random();
int data = rd.nextInt();
System.out.println("data = " + data);
}
}
在指定范围内随机一个数:
nextInt(int bound) -> 在0-(bound-1)
a.nextInt(10) -> 0-9
b.在1-10之间随机一个数: nextInt(10)+1 -> (0-9)+1 -> 1-10
c.在1-100之间随机一个数:nextInt(100)+1 -> (0-99)+1 -> 1-100
d.在100-999之间随机一个数: nextInt(900)+100 -> (0-899)+100 -> 100-999
public class Demo02Random {
public static void main(String[] args) {
//创建对象
Random rd = new Random();
//在1-100之间随机
int data1 = rd.nextInt(100)+1;
System.out.println("data1 = " + data1);
System.out.println("=====================");
//在100-999之间随机一个数
int data2 = rd.nextInt(900)+100;
System.out.println("data2 = " + data2);
}
}
第三章.switch(选择语句)
1.switch基本使用
1.格式:
switch(变量){
case 常量值1:
执行语句1;
break;
case 常量值2:
执行语句2;
break;
case 常量值3:
执行语句3;
break;
case 常量值4:
执行语句4;
break;
...
default:
执行语句n;
break;
}
2.执行流程:
用变量接收的值和下面case后面的常量值匹配,匹配上哪个case就执行哪个case对应的执行语句
如果以上所有case都没有匹配上,就走default对应的执行语句n
3.break关键字:代表的是结束switch语句
4.注意:switch能匹配什么类型的数据:
byte short int char 枚举类型 String类型
public class Demo01Switch {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请您输入一个整数:");
int data = sc.nextInt();
switch (data){
case 1:
System.out.println("鹅鹅鹅");
break;
case 2:
System.out.println("曲项向天歌");
break;
case 3:
System.out.println("白毛浮绿水");
break;
case 4:
System.out.println("红掌拨清波");
break;
default:
System.out.println("下面没有了");
break;
}
}
}
2.case的穿透性
1.如果没有break,就会出现case的穿透性,程序就一直往下穿透执行,直到遇到了break或者switch代码执行完毕了,就停止了
public class Demo02Switch {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int data = sc.nextInt();
switch (data){
case 1:
System.out.println("鹅鹅鹅");
case 2:
System.out.println("曲项向天歌");
case 3:
System.out.println("白毛浮绿水");
case 4:
System.out.println("红掌拨清波");
break;
default:
System.out.println("下面没有了");
break;
}
}
}
public class Demo03Switch {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int month = sc.nextInt();
switch(month){
case 12:
System.out.println("冬季");
break;
case 1:
System.out.println("冬季");
break;
case 2:
System.out.println("冬季");
break;
case 3:
System.out.println("春季");
break;
case 4:
System.out.println("春季");
break;
case 5:
System.out.println("春季");
break;
case 6:
System.out.println("夏季");
break;
case 7:
System.out.println("夏季");
break;
case 8:
System.out.println("夏季");
break;
case 9:
System.out.println("秋季");
break;
case 10:
System.out.println("秋季");
break;
case 11:
System.out.println("秋季");
break;
default:
System.out.println("什么情况,你家有这个月份?");
}
}
}
public class Demo03Switch {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int month = sc.nextInt();
switch(month){
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
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;
default:
System.out.println("什么情况,你家有这个月份?");
}
}
}
第四章.分支语句
1.if的第一种格式
1.格式:
if(boolean表达式){
执行语句;
}
2.执行流程:
先走if后面的boolean表达式,如果是true,就走if后面大括号中的执行语句,否则就不走
3.注意:
if后面跟的是boolean表达式,只要是结果为boolean型的,都可以放在小括号中,哪怕直接写一个true或者false
public class Demo01If {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int data1 = sc.nextInt();
int data2 = sc.nextInt();
if (data1==data2){
System.out.println("两个整数相等");
}
}
}
2.if的第二种格式
1.格式:
if(boolean表达式){
执行语句1;
}else{
执行语句2;
}
2.执行流程:
a.先走if后面的boolean表达式,如果是true,就走if后面的执行语句1
b.否则就走else后面的执行语句2
public class Demo02IfElse {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int data1 = sc.nextInt();
int data2 = sc.nextInt();
if (data1==data2){
System.out.println("两个整数相等");
}else{
System.out.println("两个整数不相等");
}
}
}
3.if的第三种格式
1.格式:
if(boolean表达式){
执行语句1
}else if(boolean表达式){
执行语句2
}else if(boolean表达式){
执行语句3
}...else{
执行语句n
}
2.执行流程:
从if开始往下挨个判断,哪个if判断结果为true,就走哪个if对应的执行语句,如果以上所有的判断都是false,就走else对应的执行语句n
3.使用场景:2种情况以上的判断
public class Demo08ElseIf {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int data1 = sc.nextInt();
int data2 = sc.nextInt();
/* if (data1>data2){
System.out.println("data1大于data2");
}else if(data1
if (data1>data2){
System.out.println("data1大于data2");
}else if(data1<data2){
System.out.println("data1小于data2");
}else if (data1==data2){
System.out.println("data1等于data2");
}
}
}
注意:最后一种情况,不一定非得用else,但是必须要保证所有的情况都判断了
> switch和if的区别:debug
>
> 1.switch:会直接跳到相匹配的case
>
> 2.if:从上到下挨个判断 -> 实际开发主要用if做判断,灵活
# 第五章.循环语句
```java
什么时候使用循环语句:
当我们发现一件事或者一段代码在反复执行,我们就可以考虑使用循环语句了
1.for循环
1.格式:
for(初始化变量;比较;步进表达式){
循环语句 -> 哪段代码循环执行,就将哪段代码放到此处
}
2.执行流程:
a.先走初始化变量
b.比较,如果是true,走循环语句,走步进表达式(初始化的变量的值进行变化)
c.再比较,如果还是true,继续走循环语句,走步进表达式
d.再比较,直到比较为false,循环结束了
public class Demo01For {
public static void main(String[] args) {
for(int i = 0;i<3;i++){
System.out.println("我爱java");
}
}
}
快捷键: 次数.fori
1.1练习
for循环:求1-3之间的数据和,并把求和结果输出到控制台上
1+2+3
步骤:
1.定义一个变量,用来接受两个数的和 sum
2.利用for循环将1-3表示出来
3.在循环的过程中,两两相加,将结果赋值给sum
4.输出sum
public class Demo02For {
public static void main(String[] args) {
//1.定义一个变量,用来接受两个数的和 sum
int sum = 0;
//2.利用for循环将1-3表示出来
for (int i = 1; i <= 3; i++) {
//3.在循环的过程中,两两相加,将结果赋值给sum
sum+=i;//sum = sum+i;
}
//4.输出sum
System.out.println("sum = " + sum);
}
}
2.while循环
1.格式:
初始化变量;
while(比较){
循环语句;
步进表达式
}
2.执行流程:
a.初始化变量
b.比较,如果是true,就走循环语句,走步进表达式
c.再比较,如果还是true,继续走循环语句,继续走步进表达式
d.再比较,直到比较为false,循环结束
public class Demo01While {
public static void main(String[] args) {
int i = 0;
while(i<5){
System.out.println("我爱java,我更爱钱");
i++;
}
}
}
public class Demo02While {
public static void main(String[] args) {
int sum = 0;
int i = 1;
while(i<=3){
sum+=i;
i++;
}
System.out.println("sum = " + sum);
}
}
public class Demo03While {
public static void main(String[] args) {
int sum = 0;
int i = 1;
while (i <= 100) {
if (i % 2 == 0) {
sum += i;
}
i++;
}
System.out.println("sum = " + sum);
}
}
public class Demo04While {
public static void main(String[] args) {
int count = 0;
int i = 1;
while (i <= 100) {
if (i % 2 == 0) {
count++;
}
i++;
}
System.out.println("count = " + count);
}
}
3.do…while循环(了解)
1.格式:
初始化变量;
do{
循环语句;
步进表达式
}while(比较);
2.执行流程:
a.初始化变量
b.走循环语句
c.走步进表达式
d.判断,如果是true,继续循环,直到比较为false,循环结束
3.特点:
至少循环一次
public class Demo01DoWhile {
public static void main(String[] args) {
int i = 0;
do{
System.out.println("我爱java");
i++;
}while(i<5);
}
}
4.循环控制关键字
1.break:
a.在switch中代表结束switch语句
b.在循环中代表结束循环
2.continue:
结束当前本次循环,直接进入下一次循环,直到条件为false为止
public class Demo01BreakAndContinue {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
if (i==3){
//结束循环
//break;
//结束本次循环,进入下一次循环
continue;
}
System.out.println("我爱java"+i);
}
}
}
5.死循环
1.概述:
一直循环
2.什么条件下一直循环:
比较条件一直是true
public class Demo01Endless {
public static void main(String[] args) {
int count = 0;
for (int i = 0; i < 10;) {
count++;
System.out.println("我爱java"+count);
}
/* while(true){
count++;
System.out.println("我爱java"+count);
}*/
}
}
6.嵌套循环
1.概述:循环中还有循环
2.执行流程:
先执行外层循环,再进入内层循环,内层循环就一直循环,直到内层循环结束,外层循环进入下一次循环,直到外层循环都结束了,整体结束
public class Demo02Nest {
public static void main(String[] args) {
for (int fen = 0; fen < 60; fen++) {
for (int miao = 0; miao < 60; miao++) {
System.out.println(fen+"分"+miao+"秒");
}
}
}
}
day05.数组
第一章.数组的定义
1.问题:想将一个数据保存起来,我们可以使用变量,但是变量一次只能存储一个数据,所以我们想能不能一次存多个数据
2.数组概述:是一个容器,数组本身属于引用数据类型
3.作用:一次存储多个数据
4.特点:
a.既可以存储基本类型的数据,还能存储引用类型的数据
b.定长(定义数组时长度为多长,最多就能存多少个数据)
5.定义:
a.动态初始化:
数据类型[] 数组名 = new 数据类型[长度]
数据类型 数组名[] = new 数据类型[长度]
各部分解释:
等号左边的数据类型:规定了数组中只能存储什么类型的元素
[]:代表的是数组,一个[]代表一维数组,两个[][]代表二维数组
数组名:自己取的名字,遵循小驼峰
new:代表的是创建数组
等号右边的数据类型:要和等号左边的数据类型一致
[长度]:指定数组长度,规定了数组最多能存多少个数据
b.静态初始化
数据类型[] 数组名 = new 数据类型[]{元素1,元素2...} -> 不推荐使用
数据类型 数组名[] = new 数据类型[]{元素1,元素2...} -> 不推荐使用
c.简化的静态初始化:
数据类型[] 数组名 = {元素1,元素2...}-> 推荐使用
6.区别:
a.动态初始化:定义的时候只指定了长度,没有存具体的数据
当只知道长度,但不知道具体存啥数据时可以使用动态初始化
b.静态初始化:定义的时候就直接知道存啥了
public class Demo01Array {
public static void main(String[] args) {
//动态初始化
int[] arr1 = new int[3];
String[] arr2 = new String[3];
//静态初始化
int[] arr3 = new int[]{1,2,3,4,5};
//简化静态初始化
int[] arr4 = {1,2,3,4,5};
String[] arr5 = {"乾隆","和珅","纪晓岚"};
}
}
第二章.数组操作
1.获取数组的长度
1.格式:
数组名.length
2.注意:
length后面不要带小括号,因为length不是一个方法,而是数组中的一个属性
public class Demo01Array {
public static void main(String[] args) {
//定义一个数组
String[] arr1 = {"迪迦奥特曼","猫和老鼠","花园宝宝","海绵宝宝","圣斗士","百变小樱魔术卡","熊出没"};
int len = arr1.length;
System.out.println("len = " + len);
}
}
2.索引
1.概述:元素在数组中存储的位置
2.特点:
a.索引唯一
b.索引都是从0开始的,最大索引是数组长度-1
3.注意:
我们将来操作元素,必须通过索引来操作
存数据,要指定索引
取数据,要指定索引
查数据,要指定索引
3.存储元素
1.格式:
数组名[索引值] = 值 -> 将等号右边的值放到数组指定的索引位置上
public class Demo02Array {
public static void main(String[] args) {
int[] arr = new int[3];
arr[0] = 100;//将100存到了arr这个数组的0索引上
arr[1] = 200;//将200存到了arr这个数组的1索引上
arr[2] = 300;//将300存到了arr这个数组的2索引上
//arr[3] = 1000;
System.out.println("============================");
String[] arr1 = new String[3];
arr1[0] = "东方不败";
arr1[1] = "岳不群";
arr1[2] = "林平之";
}
}
public class Demo03Array {
public static void main(String[] args) {
//键盘录入三个整数,存储到数组中
int[] arr = new int[3];
Scanner sc = new Scanner(System.in);
/*
先看等号右边的,先录入,将录入的数据保存到指定的索引位置上
*/
/* arr[0] = sc.nextInt();
arr[1] = sc.nextInt();
arr[2] = sc.nextInt();*/
/* for (int i = 0; i < 3; i++) {
arr[i] = sc.nextInt();
}*/
for (int i = 0; i < arr.length; i++) {
arr[i] = sc.nextInt();
}
}
}
public class Demo04Array {
public static void main(String[] args) {
//定义一个长度为3的数组
int[] arr = new int[3];
Random rd = new Random();
//arr[0] = rd.nextInt(10);
//arr[1] = rd.nextInt(10);
//arr[2] = rd.nextInt(10);
for (int i = 0;i<arr.length;i++){
/*
先看等号右边的,先随机一个数保存到指定的索引位置上
*/
arr[i] = rd.nextInt(10);
}
}
}
4.获取元素
1.地址值:
数组在内存中的身份证号,唯一标识,我们可以通过这个唯一标识到内存中准确找到这个数,从而操作这个数组中的数据
2.注意:
a.直接输出数组名,会直接输出数组在内存中的地址值
b.如果数组中没有存元素,那么直接获取索引上对应的元素也是有值的,只不过不是我们存储的数据,而是数组中的元素默认值
整数: 0
小数: 0.0
字符: '\u0000' -> 空白字符 -> 对应的int值是0
布尔: false
引用: null
public class Demo05Array {
public static void main(String[] args) {
int[] arr = new int[3];
arr[0] = 100;
arr[1] = 200;
arr[2] = 300;
System.out.println(arr);//[I@135fbaa4 -> 地址值
System.out.println(arr[0]);//输出0索引上的元素
System.out.println(arr[1]);//输出1索引上的元素
System.out.println(arr[2]);//输出2索引上的元素
int[] arr1 = new int[3];
arr1[0] = 1000;
arr1[1] = 2000;
arr1[2] = 3000;
System.out.println(arr1);//[I@45ee12a7
System.out.println(arr1[0]);//输出0索引上的元素
System.out.println(arr1[1]);//输出1索引上的元素
System.out.println(arr1[2]);//输出2索引上的元素
System.out.println("=============================");
int[] arr2 = new int[3];
System.out.println(arr2[0]);//输出0索引上的元素 0
System.out.println(arr2[1]);//输出1索引上的元素 0
System.out.println(arr2[2]);//输出2索引上的元素 0
}
}
public class Demo06Array {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
//需求:将arr中的数据放到另外一个数组中
/*
如果我们想将arr中的数据复制到新数组中
那么新数组的长度就应该是arr数组的长度
*/
int[] newArr = new int[arr.length];
System.out.println(newArr[0]);//默认值0
System.out.println(newArr[1]);//默认值0
System.out.println(newArr[2]);//默认值0
System.out.println(newArr[3]);//默认值0
System.out.println(newArr[4]);//默认值0
System.out.println(newArr[5]);//默认值0
/*
将arr数组指定索引位置上的元素获取出来放到等号左边newArr数组的指定索引位置上
*/
newArr[0] = arr[0];
newArr[1] = arr[1];
newArr[2] = arr[2];
newArr[3] = arr[3];
newArr[4] = arr[4];
newArr[5] = arr[5];
System.out.println(newArr[0]);
System.out.println(newArr[1]);
System.out.println(newArr[2]);
System.out.println(newArr[3]);
System.out.println(newArr[4]);
System.out.println(newArr[5]);
}
}
arr[0] = arr1[0]
如果数组名[索引值]在等号右边就代表获取
如果数组名[索引值]在等号左边就代表存值
比如 :
a.int element = arr[0] -> 获取0索引上的元素,赋值给一个变量
b.arr[0] = 100 -> 将100存储到0索引上
c.arr[0] = arr1[0] -> 将arr1的0索引上的元素获取出来,赋值给等号左边arr的0索引上
5.遍历数组
1.遍历:将元素从数组中一个一个的获取出来
public class Demo07Array {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6};
/*for (int i = 0; i < 6; i++){
System.out.println(arr[i]);
}*/
/* for (int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}*/
/*
快速遍历快捷键: 数组名.fori
*/
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
快速遍历快捷键: 数组名.foripublic class Demo08Array { public static void main(String[] args) { int[] arr = {1,2,3,4,5,6}; //需求:将arr中的数据放到另外一个数组中 /* 如果我们想将arr中的数据复制到新数组中 那么新数组的长度就应该是arr数组的长度 */ int[] newArr = new int[arr.length]; System.out.println(newArr[0]);//默认值0 System.out.println(newArr[1]);//默认值0 System.out.println(newArr[2]);//默认值0 System.out.println(newArr[3]);//默认值0 System.out.println(newArr[4]);//默认值0 System.out.println(newArr[5]);//默认值0 /* 将arr数组指定索引位置上的元素获取出来放到等号左边newArr数组的指定索引位置上 */ /* newArr[0] = arr[0]; newArr[1] = arr[1]; newArr[2] = arr[2]; newArr[3] = arr[3]; newArr[4] = arr[4]; newArr[5] = arr[5];*/ for (int i = 0; i < arr.length; i++) { newArr[i] = arr[i]; } //遍历 for (int i = 0; i < newArr.length; i++) { System.out.println(newArr[i]); } } }
第三章.操作数组时两个常见的问题
1.数组索引越界异常_ArrayIndexOutOfBoundsException
1.原因:
操作的索引超出了数组索引范围了
public class Demo09Array {
public static void main(String[] args) {
int[] arr = new int[3];
arr[0] = 100;
arr[1] = 200;
arr[2] = 300;
//arr[3] = 400;//索引3超出了arr的索引范围
//arr[-1] = 1000;//索引3超出了arr的索引范围
for (int i = 0; i <= arr.length; i++) {
System.out.println(arr[i]);//索引3超出了arr的索引范围
}
}
}
2.空指针异常_NullPointerException
1.原因:
当一个对象为null时,再调用此对象中的其他成员
public class Demo10Array {
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr.length);//3
arr = null;
System.out.println(arr.length);//NullPointerException
}
}
以上两个问题我们只需要知道原因即可
第四章.内存图
1.内存:可以理解"内存条",任何程序,软件运行起来都会在内存中运行,占用内存,在java的世界中,将内存分为了5大块
2.分为哪5大块
栈(重点)(Stack)
主要运行方法,方法的运行都会去栈内存中运行,运行完毕之后,需要"弹栈",腾空间
堆(重点):(Heap)
每new一次,都会在堆内存中开辟空间,并为此空间自动分配一个地址值
堆中的数据都是有默认值的
整数:0
小数:0.0
字符: '\u0000'
布尔:false
引用:null
方法区(重点)(Method Area)
代码的"预备区",记录了类的信息以及方法的信息
本地方法栈(了解):专门运行native方法(本地方法)
本地方法可以理解为对java功能的扩充
有很多功能java语言实现不了,所以就需要依靠本地方法完成
寄存器(了解) -> 跟CPU有关
1.一个数组内存图
2.两个数组内存图
我们创建了两个数组,在堆内存中开辟了两个不同的空间,此时修改一个数组中的元素不会影响到另外一个数组中的数据
3.两个数组指向同一片内存空间
arr2不是new出来的,是arr1直接赋值的,arr1在内存中保存的是地址值,给了arr2,那么arr2的地址值和arr1就是一样的
所以此时arr1和arr2指向了堆内存中的同一片空间(同一个地址值,同一个数组),此时改变一个数组中的元素会影响到另外一个数组
第五章.二维数组
1.二维数组的定义格式
1.概述:数组中的套多个数组
2.定义格式
a.动态初始化
数据类型[][] 数组名 = new 数据类型[m][n]
数据类型 数组名[][] = new 数据类型[m][n]
数据类型[] 数组名[] = new 数据类型[m][n]
m:代表的是二维数组的长度
n:代表的是二维数组中每一个一维数组的长度
数据类型[][] 数组名 = new 数据类型[m][] -> 二维数组中的一维数组没有被创建
b.静态初始化
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
数据类型 数组名[][] = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
数据类型[] 数组名[] = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
c.简化静态初始化:
数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
数据类型 数组名[][] = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
数据类型[] 数组名[] = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}}
public class Demo01Array {
public static void main(String[] args) {
int[][] arr1 = new int[2][2];
int[][] arr2 = new int[2][];
System.out.println("======================");
String[][] arr3 = {{"孙悟空","唐僧"},{"刘备","关羽","张飞"},{"宋江"},{"林黛玉","贾宝玉","王熙凤","薛宝钗"}};
}
}
2.获取二维数组长度
1.格式:
数组名.length
2.获取每一个一维数组长度,需要先遍历二维数组,将每一个一维数组从二维数组中拿出来
public class Demo02Array {
public static void main(String[] args) {
String[][] arr = {{"张三","李四"},{"王五","赵六","田七"},{"猪八","牛九"}};
System.out.println(arr.length);
for (int i = 0; i < arr.length; i++) {
/*
arr[i]代表的是每一个一维数组
*/
System.out.println(arr[i].length);
}
}
}
3.获取二维数组中的元素
1.格式:
数组名[i][j]
i:代表的是一维数组在二维数组中的索引位置
j:代表的是元素在一维数组中的索引位置
public class Demo03Array {
public static void main(String[] args) {
String[][] arr = {{"张三","李四"},{"王五","赵六","田七"},{"猪八","牛九"}};
System.out.println(arr[0][0]);
System.out.println(arr[2][0]);
System.out.println(arr[1][1]);
}
}
4.二维数组中存储元素
1.格式:
数组名[i][j] = 值
i:代表的是一维数组在二维数组中的索引位置
j:代表的是元素在一维数组中的索引位置
public class Demo04Array {
public static void main(String[] args) {
String[][] arr = new String[2][2];
arr[0][0] = "张飞";
arr[0][1] = "李逵";
arr[1][0] = "刘备";
arr[1][1] = "宋江";
System.out.println(arr[0][0]);
System.out.println(arr[0][1]);
System.out.println(arr[1][0]);
System.out.println(arr[1][1]);
}
}
5.二维数组的遍历
1.先遍历二维数组,将每一个一维数组遍历出来
2.再遍历每一个一维数组,将元素获取出来
public class Demo05Array {
public static void main(String[] args) {
String[][] arr = new String[2][2];
arr[0][0] = "张飞";
arr[0][1] = "李逵";
arr[1][0] = "刘备";
arr[1][1] = "宋江";
//遍历二维数组
for (int i = 0; i < arr.length; i++) {
/*
arr[i]代表的每一个一维数组
*/
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}
}
6.二维数组内存图
public class Demo06Array {
public static void main(String[] args) {
int[][] arr1 = new int[3][];
arr1[1] = new int[]{1,2,3};
arr1[2] = new int[3];
arr1[2][1] = 100;
}
}
模块六_方法
第一章.方法的使用
1.方法介绍以及简单方法定义(无参无返回值)
1.问题描述:
之前所有的代码都在main方法中写,如果我们将来将所有功能的代码都放到main方法中,会显得main方法代码太多,太乱,太臃肿-> 不好维护
解决:将不同功能的代码放到不同的方法中,想执行某个功能,直接调用方法名就行了,对应的代码就自动执行起来了
将来维护的时候,直接找到对应的方法,就可以对其直接修改维护
2.方法:
拥有功能性代码的代码块
将不同的功能放在不同的方法中,给每个方法取个名字,直接调用方法名,对应的方法就执行起来了,好维护
3.通用定义格式:
修饰符 返回值类型 方法名(参数){
方法体
return 结果
}
4.通过通用格式,分成四种方法来学习:
a.无参无返回值方法
b.有参无返回值方法
c.无参有返回值方法
d.有参有返回值方法
1.无参无返回值方法定义:
public static void 方法名(){
方法体 -> 实现此方法的具体代码
}
2.调用:直接调用
在其他方法中: 方法名()
3.注意事项:
a.void关键字代表无返回值,写了void,就不要在方法中写return 结果
b.方法不调用不执行, main方法是jvm调用的
c.方法之间不能互相嵌套,方法之间是平级关系
d.方法的执行顺序只和调用顺序有关
public class Demo01Method {
public static void main(String[] args) {
farmer();
cook();
me();
cook();
}
//农民伯伯
public static void farmer(){
System.out.println("播种");
System.out.println("施肥");
System.out.println("拔草");
System.out.println("浇水");
System.out.println("除虫");
System.out.println("收割");
}
//厨师
public static void cook(){
System.out.println("洗菜");
System.out.println("切菜");
System.out.println("炒菜");
System.out.println("装盘");
System.out.println("上菜");
}
//我们自己
public static void me(){
System.out.println("洗手");
System.out.println("吃菜");
}
}
定义一个方法,实现两个整数相加
public class Demo02Method {
public static void main(String[] args) {
sum();
System.out.println("哈哈哈哈哈");
}
public static void sum(){
int a = 10;
int b = 20;
int sum = a+b;
System.out.println("sum = " + sum);
}
}
2.无参数无返回值的方法执行流程
3.方法定义各部分解释
1.通用格式:
修饰符 返回值类型 方法名(参数){
方法体
return 结果
}
2.各部分解释:
a.修饰符: public static
b.返回值类型:
该方法最终返回的结果的数据类型
比如: return 1 -> 方法上的返回值类型写int
return 2.5 -> 方法上的返回值类型写double
return "" -> 方法上的返回值类型写String
如果没有返回值,不要写具体的返回值类型了,要写void
c.方法名:见名知意(小驼峰式)
d.参数:进入到方法内部参与执行的数据(数据类型 变量名,数据类型 变量名)
e.方法体:实现该方法的具体代码
f.return 结果: 如果有返回值,可以利用return 将结果返回
4.有参数无返回值的方法定义和执行流程
1.格式:
public static void 方法名(数据类型 变量名){
方法体
}
2.调用:
直接调用:方法名(具体的值) -> 调用的时候要给参数赋值
需求:定义一个方法,实现两个整数相加
public class Demo03Method {
public static void main(String[] args) {
sum(10,20);
}
public static void sum(int a,int b){
int sum = a+b;
System.out.println("sum = " + sum);
}
}
5.无参数有返回值定义以及执行流程
1.格式:
public static 返回值类型 方法名(){
方法体
return 结果
}
2.调用: 返回值返回给了谁? 哪里调用返回给哪里
a.打印调用:sout(方法名()) -> 不推荐使用
b.赋值调用:调用完之后用一个变量接收返回值结果 -> 极力推荐
数据类型 变量名 = 方法名()
需求:定义一个方法,实现两个整数相加,将结果返回
public class Demo04Method {
public static void main(String[] args) {
//打印调用 -> 涛哥不推荐
System.out.println(sum());
//赋值调用-> 极力推荐
int result = sum();
System.out.println("result = " + result);
}
public static int sum(){
int a = 10;
int b = 20;
int sum = a+b;
return sum;
//return a+b;
}
}
6.有参数有返回值定义以及执行流程
1.格式:
public static 返回值类型 方法名(参数){
方法体
return 结果
}
2.调用:
a.打印调用:
sout(方法名(具体的值))
b.赋值调用(极力推荐)
数据类型 变量名 = 方法名(具体的值)
需求:定义一个方法,实现两个整数相加,将结果返回
public class Demo05Method {
public static void main(String[] args) {
int sum = sum(10, 20);
System.out.println("sum = " + sum);
}
public static int sum(int a,int b){
int sum = a+b;
return sum;
}
}
7.形式参数和实际参数区别
1.形式参数(形参):在定义方法的时候形式上定义的参数,此参数还没有值
2.实际参数(实参):在调用方法的时候给形参赋予的具体的值
8.参数和返回值使用的时机
1.参数:
当想将方法A的数据传递到方法B时,那么定义方法B时就需要带个参数,在方法A中调用方法B时,可以将方法A中的数据通过参数传递到方法B中
2.返回值:
调用方法A时,想要方法A的结果,去参与其他的操作,那么方法A就需要将自己的结果返回
1.controller接收的请求参数需要一层一层传递到service层,service层需要将请求参数再传递到dao层
此时service的方法以及dao的方法都需要参数,去接收
2.dao层的结果需要传递给service,service再传递给controller层,此时dao层和service方法需要返回值
9.变量作为实参使用
需求:定义一个方法,比较两个整数的大小,如果第一个比第二个大,返回true,否则返回false
public class Demo07Method {
public static void main(String[] args) {
int i = 10;
int j = 20;
//传递的是i和j,但是我们真正传递的是i和j代表的数据,不是变量本身
boolean result = compare(i, j);
System.out.println("result = " + result);
}
public static boolean compare(int a,int b){
if (a>b){
return true;
}else{
return false;
}
}
}
第二章.方法注意事项终极版
1.方法不调用不执行
2.方法的执行顺序只和调用顺序有关
3.方法之间不能互相嵌套
4.void不能和[return 结果]共存,但是void能和[return]共存
a.void:代表没有返回值
b.return 结果:就代表有返回值了
先将结果返回,然后结束方法
c.return:仅仅代表结束方法,不代表有返回值
5.一个方法中不能连续写多个return(也就是说一个方法不能都多个返回值)
6.调用方法的时候要看看下面有没有这个方法,没有的方法直接调用会报错
public class Demo08Method {
public static void main(String[] args) {
method01();
//method04();
}
public static int method01(){
return 1;
}
public static void method02(){
return;
}
public static int method03(){
return 1;
//return 2;
}
}
初学者怎么写: 1.先定义,再调用 2.如果是没有返回值的方法,直接在被调用的方法内部输出结果 3.如果是带返回值的方法,就调用完毕之后,用一个变量去接收结果,输出这个变量 4.调用方法: 直接调用:方法名() 或者 方法名(实参) -> 只针对于无返回值的方法 打印调用:sout(方法名()) 或者 sout(方法名(实参)) -> 针对有返回值的方法 -> 不推荐使用 赋值调用:数据类型 变量名 = 方法名() 或者 数据类型 变量名 = 方法名(实参) -> 针对于有返回值的方法 -> 推荐使用怎么练习: 1.如果定义的方法没有返回值,写个void 不要写return 结果 2.如果定义的方法有返回值,就将void改成具体的返回值类型,在 方法体中最后写一个return 结果,将结果返回 3.如果方法有返回值,调用的时候推荐使用赋值调用,如果没有返回值,使用直接调用 4.练习的时候,只需要完成一个简单的需求(比如两个整数相加),针对此需求,定义4种方法,并成功调用
第三章.方法练习
返回值为引用数据类型时,返回的是地址值
第四章.方法的重载(Overload)
需求:定义三个方法,分别求2个整数相加,3个整数相加,4个整数相加
public class Demo1OverLoad {
public static void main(String[] args) {
sum(10,20);
sum(10,20,30);
sum(10,20,30,40);
}
//两个整数相加
public static void sum(int a,int b){
System.out.println(a+b);
}
//三个整数相加
public static void sum(int a,int b,int c){
System.out.println(a+b+c);
}
//四个整数相加
public static void sum(int a,int b,int c,int d){
System.out.println(a+b+c+d);
}
}
1.概述:方法名相同,参数列表不同的方法
2.什么叫参数列表不同:
a.参数个数不同
b.参数类型不同
c.参数类型顺序不同
3.判断两个方法是否为重载方法,和什么无关:
a.和参数名无关
b.和返回值无关
public static void open(){}
public static void open(int a){}
static void open(int a,int b){}
public static void open(double a,int b){}
public static void open(int a,double b){}
public void open(int i,double d){}
public static void OPEN(){}
public static void open(int i,int j){}
如果定义方法功能一样,只不过实现细节不一样,就可以考虑定义成重载的方法
模块七_面向对象
第一章.类和对象
1.面向对象的介绍
1.面向过程:自己的事情自己干,代表语言C语言
洗衣服:每一步自己要亲力亲为 -> 找个盆,放点水,找个搓衣板,搓搓搓
2.面向对象:自己的事情别人帮忙去干,代表语言Java语言
洗衣服:自己的事情别人干 -> 全自动洗衣机
3.为啥要使用面向对象思想编程:懒
很多功能别人都给我们实现好了,我们只需要直接拿过来使用即可,简化了我们自己的编写过程,减少了我们的代码量
4.什么时候使用面向对象思想编程:
调用别人的功能时
在一个类中想使用别的类中的成员时,就使用面向对象思想编程
至于我们使用的功能人家怎么实现的,我们不需要关心,我们只需要知道怎么使用即可
5.怎么使用面向对象思想编程:
a.new呀,new完点呀-> 点代表的是调用
b.特殊:如果调用的成员带static关键字,我们不需要new,我们直接类名点即可
public class Demo01Object {
public static void main(String[] args) {
/*
我们想在Demo01Object类中使用Scanner类中的next方法实现录入字符串
那么我们就需要使用面向对象思想编程
对象:Scanner-> new出来的
对象实现好的功能:next()
我们只需要知道找来Scanner这个对象,就可以调用这个对象中实现好的next方法
至于next方法怎么实现的,我们不需要关心
*/
Scanner sc = new Scanner(System.in);
String data = sc.next();
System.out.println("data = " + data);
System.out.println("===================================");
/*
我们想在Demo01Object类中使用Random类中的nextInt方法实现随机整数
那么我们就需要使用面向对象思想编程
对象:Random -> new出来的
对象实现好的功能:nextInt()
我们只需要知道找来Random这个对象,就可以调用Random中的nextInt方法
至于nextInt怎么实现的,我们不需要关心
*/
Random rd = new Random();
int data2 = rd.nextInt();
System.out.println("data2 = " + data2);
System.out.println("====================================");
int[] arr = {1,2,3,4};//[1,2,3,4]
/* System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i== arr.length-1){
System.out.print(arr[i]+"]");
}else{
System.out.print(arr[i]+",");
}
}*/
/*
Arrays就是我们找来的对象
toStrig就是此对象中实现好的功能
我们只需要调用,怎么实现我们不关心
*/
System.out.println(Arrays.toString(arr));
}
}
2.类和对象
2.1类(实体类)_class
1.测试类:带main方法的类,主要是运行代码的
2.实体类:是一类事物的抽象表示形式
世间万物的分类:比如: 人类 狗类 猫类 鼠标类
组成部分:
1.属性(成员变量):这一类事物有啥
a.定义位置:类中方法外
b.作用范围:作用于当前类
c.定义格式: 数据类型 变量名
d.默认值:
整数:0
小数:0.0
字符:'\u0000'
布尔:false
引用:null
2.行为(成员方法):这一类事物都能干啥
只需要将模块六所学的方法中的static干掉,其他的都一样
public class Person {
//属性-> 成员变量
String name;
int age;
//行为 -> 成员方法
public void eat(){
System.out.println("人要干饭");
}
public void drink(){
System.out.println("人要喝水");
}
}
描述动物类
public class Animal { String kind;//品种 String color;//颜色 public void eat(){ System.out.println("动物要吃饭"); } public void sleep(){ System.out.println("动物都睡觉"); } }描述手机类
public class Phone { //属性 String brand; String color; int price; //行为 public void call(String name){ System.out.println("给"+name+"打电话"); } public String message(){ return "给金莲发短信"; } }
2.2对象
1.概述:一类事物的具体体现
2.使用:
a.导包: import 包名.类名
如果两个类在同一个包下,想要使用对方的成员不需要导包
如果两个类不在同一个包下,想要使用对方的成员需要导包
特殊包:java.lang -> 使用lang包下的类不需要导包 -> String
友情提示:在学四种权限修饰符之前,尽量让两个类在同一个包下
b.创建对象:想要使用哪个类中的成员,就new哪个类的对象
类名 对象名 = new 类名() -> 比如: Person person = new Person()
c.调用成员(成员变量,成员方法) -> 想要使用哪个类中的成员,就用哪个类的对象去点哪个成员
对象名.成员变量名 = 值
对象名.方法名() -> 调用的是无参无返回值方法
对象名.方法名(实参) -> 调用的是有参无返回值方法
数据类型 变量名 = 对象名.方法名() -> 调用的是无参有返回值方法
数据类型 变量名 = 对象名.方法名(实参) -> 调用的是有参有返回值方法
public class Person {
//属性-> 成员变量
String name;
int age;
//行为 -> 成员方法
public void eat(){
System.out.println("人要干饭");
}
public void drink(){
System.out.println("人要喝水");
}
}
public class Demo01Person {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);
System.out.println(person.age);
person.name = "金莲";
person.age = 26;
System.out.println(person.name);
System.out.println(person.age);
person.eat();
person.drink();
}
}
3.匿名对象的使用
1.int i = 10 a.int:是数据类型 b.i:变量名 c.等号右边的10:真正的数据 2.Person p = new Person() a.等号左边的Person:对象的类型,好比是int b.p:对象名 c.等号右边的new Person():真正的数据,是一个Person对象,将这个对象真正创建出来了
1.所谓的匿名对象:其实就是没有等号左边的部分,只有等号右边的部分(对象)
2.使用:
new 对象().成员
3.注意:
a.如果我们只想单纯的调用一个方法,让方法执行,我们可以考虑使用匿名对象
b.但是如果涉及到赋值,千万不要用匿名对象
public class Person {
String name;
public void eat(){
System.out.println("人要吃饭");
}
}
public class Demo01Person {
public static void main(String[] args) {
//原始方式
Person p = new Person();
p.name = "金莲";
System.out.println(p.name);
p.eat();
System.out.println("=================");
//匿名对象
new Person().eat();
new Person().name = "大郎";
System.out.println(new Person().name);//null
}
}
4.一个对象的内存图
5.两个对象的内存图
phone1和phone2都是new出来的,所以在堆内存中产生了两个不同的空间,所以改变一个空间的数据不会 影响另外一个空间中的数据
6.两个对象指向同一片空间内存图
phone2是phone1给的,phone1在内存中保存的是地址值,此时phone1和phone2地址值是一样的了,操作的是同一片空间的数据,所以改变一个对象的数据会影响到另外一个对象
第二章.成员变量和局部变量的区别
1.定义位置不同(重点)
a.成员变量:类中方法外
b.局部变量:定义在方法之中或者参数位置
2.初始化值不同(重点)
a.成员变量:有默认值的,所以不用先手动赋值,就可以直接使用
b.局部变量:是没有默认值的,所以需要先手动赋值,再使用
3.作用范围不同(重点)
a.成员变量:作用于整个类
b.局部变量:只作用于自己所在的方法,其他方法使用不了
4.内存位置不同(了解)
a.成员变量:在堆中,跟着对象走
b.局部变量:在栈中,跟着方法走
5.生命周期不同(了解)
a.成员变量:随着对象的创建而产生,随着对象的消失而消失
b.局部变量:随着方法的调用而产生,随着方法的调用完毕而消失
public class Person {
String name;//成员变量
public void eat(){
int i = 10;//局部变量
System.out.println(i);
System.out.println(name);//成员变量不用手动赋值可以直接使用,因为有默认值
}
public void drink(){
int j;
//System.out.println(j);//局部变量没有默认值,所以需要手动赋值再使用
System.out.println(name);
//System.out.println(i);//i是eat方法的局部变量,在drink中使用不了
}
}
给引用数据类型赋值,需要new对象(String比较特殊,可以直接=赋值)
模块八_封装
第一章.封装
将一个物品封装起来,外界不能直接使用了,提高了物品的安全性
1.封装的介绍以及使用
1.面向对象三大特征: [封装] 继承 多态
2.什么是封装思想:
a.我们找来了一个对象(洗衣机),只需要按一下按钮就可以了(使用洗衣机功能的过程就是在使用面向对象思想编程的过程),每一个按钮下面都包含了很多内部结构的细节(细节被封装到按钮里面了->封装),在使用的时候有必要了解洗衣机的内部构造吗?我们没有必要去了解内部结构,我们只知道调用就可以了
所以,洗衣机来说,将细节隐藏起来了,细节我们不要关注,会对外提供了一个公共的接口(按钮),供我们人类使用
b.隐藏对象内部的复杂性,只对外提供公开,公共的接口,便于外界调用,从而提高了系统的可扩展性,可维护性,安全性,通俗来说,把该隐藏的隐藏起来(细节),把该暴露的暴露出来(对外提供的供别人使用的接口),这就是封装思想
我们只需要调用这个接口(功能)即可,此接口背后封装起来的细节就开始执行了,但是我们不需要关注细节,只关注公共的接口怎么调用
c.将细节隐藏起来,不让外界随便使用,但是我们可以提供一个公共的接口让外界间接使用隐藏起来的细节->封装思想
1.问题:
定义成员变量,只要是new出来对象,就可以随便调用,随便赋值,哪怕是不合理的值我们也挡不住,怎么办?
将属性封装起来(隐藏细节)
a.关键字:private(私有化的) -> 被private修饰的成员只能在本类中使用,在别的类中使用不了
b.注意:
将代码放到一个方法中,也是封装的体现
一个成员被private修饰也是封装的体现,只不过private最具代表性
c.private的使用:
修饰成员变量:private 数据类型 变量名
修饰方法:将public改成private,其他的都一样
2.问题:属性被私有化了,外界直接调用不了了,那么此时属性就不能直接赋值取值了,所以需要提供公共的接口
get/set方法
set方法:为属性赋值
get方法:获取属性值
public class Person {
private String name;
private int age;
//为name提供get/set方法
public void setName(String xingMing) {
name = xingMing;
}
public String getName() {
return name;
}
//为age提供get/set方法
public void setAge(int nianLing) {
if (nianLing < 0 || nianLing > 150) {
System.out.println("你脑子是不是秀逗啦!岁数不合理");
} else {
age = nianLing;
}
}
public int getAge() {
return age;
}
}
public class Test01 {
public static void main(String[] args) {
Person person = new Person();
//person.name = "涛哥";
//person.age = -18;
//System.out.println(person.name);
//System.out.println(person.age);
person.setName("涛哥");
person.setAge(18);
String name = person.getName();
int age = person.getAge();
System.out.println(name+"..."+age);
}
}
小结:
用private将属性封装起来,外界不能直接调用,保护了属性
对外提供一套公共的接口(set/get方法),让外界通过公共的接口间接使用封装起来的属性
2.this的介绍
1.如果成员变量和局部变量重名时,我们遵循"就近原则",先访问局部变量
2.this概述:代表的是当前对象
3.作用:this可以区分重名的成员变量和局部变量
this点出来的一定是成员的变量
4.this代表当前对象,那么具体代表哪个对象呢?
哪个对象调用的this所在的方法,this就代表哪个对象
public class Person {
String name;
/*
哪个对象调用的this所在的方法,this就代表哪个对象
*/
public void speak(String name){
System.out.println(this+"........");
System.out.println(this.name+"您好,我是"+name);
}
}
public class Test01 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person+"=========");
person.name = "沉香";
person.speak("刘彦昌");
System.out.println("==========");
Person person2 = new Person();
System.out.println(person2+"+++++");
person2.name = "奥特曼";
person2.speak("奥特曼之父");
}
}
public class Person {
private String name;
private int age;
//为name提供get/set方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
//为age提供get/set方法
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
public class Test01 {
public static void main(String[] args) {
Person person = new Person();
person.setName("涛哥");
person.setAge(16);
System.out.println(person.getName()+"..."+person.getAge());
}
}
3.构造方法
1.概述:方法名和类名一致并且能初始化对象的方法
2.分类:
a.无参构造:没有参数
b.有参构造:有参数,参数是为指定的属性赋值
c.满参构造:给所有属性赋值
以上构造咱们不用记那么详细,我们就记有参和无参构造就可以了
3.特点:
a.方法名和类名一致
b.没有返回值,连void都没有
3.1空参构造
1.格式:
public 类名(){
}
2.作用:
new对象使用
3.特点:
每个类中默认都有一个无参构造,不写也有,jvm会自动提供
4.使用:一new对象就是在调用构造方法
3.2有参构造
1.格式:
public 类名(形参){
为属性赋值
}
2.作用:
a.new对象
b.为属性赋值
3.特点:
jvm不会自动提供有参构造,但是将有参构造手写出来,jvm将不再提供无参构造,所以建议有参,无参的构造都手写上去
public class Person {
private String name;
private int age;
//无参构造
public Person(){
System.out.println("我是无参构造");
}
//有参构造
public Person(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 class Test01 {
public static void main(String[] args) {
Person person = new Person();
Person person2 = new Person("涛哥", 18);
System.out.println(person2.getName()+"..."+person2.getAge());
}
}
如何快速知道调用的成员是哪个类中的哪个成员呢?
按住ctrl不放,鼠标点击对应的成员 -> 会跳到对应的位置
4.标准JavaBean
JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean` 的类，要求：
（1）类必须是具体的(非抽象 abstract)和公共的，public class 类名
（2）并且具有无参数的构造方法，有参构造
（3）成员变量私有化，并提供用来操作成员变量的set 和get 方法。
com.atguigu.controller -> 专门放和页面打交道的类(表现层)
com.atguigu.service -> 专门放业务处理的类 (业务层)
com.atguigu.dao -> 专门放和数据库打交道的类(持久层)
com.atguigu.pojo -> 专门放javabean类
com.atguigu.utils -> 专门放工具类
public class Person {
private String name;
private int age;
//无参构造
public Person(){
}
//有参构造
public Person(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 class Test01 {
public static void main(String[] args) {
Person person = new Person();
person.setName("金莲");
person.setAge(26);
System.out.println(person.getName()+"..."+person.getAge());
Person person2 = new Person("涛哥", 18);
System.out.println(person2.getName()+"..."+person2.getAge());
}
}
编写符合JavaBean 规范的类，以学生类为例，标准代码如下：
public class Student {
private int sid;
private String sname;
public Student() {
}
public Student(int sid, String sname) {
this.sid = sid;
this.sname = sname;
}
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
}
快速生成标准javabean通用快捷键:alt+insert
public class Test01 {
public static void main(String[] args) {
Student s1 = new Student();
s1.setSid(1);
s1.setSname("涛哥");
System.out.println(s1.getSid()+"..."+s1.getSname());
System.out.println("==============");
Student s2 = new Student(2, "金莲");
System.out.println(s2.getSid()+"..."+s2.getSname());
}
}
小结:
1.知道private的作用嘛?私有的,别的类不能直接调用
2.知道空参构造作用嘛?new对象
3.知道有参构造作用嘛? new对象 为属性赋值
4.知道set方法作用嘛? 为属性赋值
5.知道get方法作用嘛? 获取属性值
6.知道this的作用嘛? 区分重名的成员变量和局部变量
7.知道快捷键生成标准javabean嘛? alt+insert
5.JavaBean怎么来的
1.将来的javabean都是和数据库的表相关联
a.类名 -> 表名
b.属性名 -> 列名
c.对象 -> 表中每一行数据
d.属性值 -> 表中单元格中的数据
将页面填写的数据获取到,封装到javabean中,一层一层传递到dao层,然后将javabean中的属性值获取出来放到表中保存 -> 相等于是一个添加功能
将所有的数据查询出来,封装成一个一个的javabean对象,然后将封装好的javabean对象放到一个容器中,将此容器返回 给页面,在页面上遍历展示
模块九_面向对象
第一章.static关键字
1.static的介绍以及基本使用
1.概述:static是一个静态关键字
2.使用:
a.修饰一个成员变量:
static 数据类型 变量名
b.修饰一个方法:
修饰符 static 返回值类型 方法名(形参){
方法体
return 结果
}
3.调用静态成员:
类名直接调用(不用new对象)
4.静态成员特点:
a.静态成员属于类成员,不属于对象成员(非静态的成员属于对象成员)
b.静态成员会随着类的加载而加载
c.静态成员优先于非静态成员存在在内存中
d.凡是根据静态成员所在的类创建出来的对象,都可以共享这个静态成员
public class Student {
String name;
int age;
static String classRoom;
}
public class Test01 {
public static void main(String[] args) {
//先给静态成员赋个值
Student.classRoom = "222";
Student s1 = new Student();
s1.name = "郭靖";
s1.age = 28;
//s1.classRoom = "111";
System.out.println(s1.name+","+s1.age+","+Student.classRoom);
System.out.println("==============");
Student s2 = new Student();
s2.name = "黄蓉";
s2.age = 26;
//s2.classRoom = "111";
System.out.println(s2.name+","+s2.age+","+Student.classRoom);
}
}
2.static修饰成员的访问特点
1.在静态方法中能直接访问非静态成员嘛? 不能
想要调用的话:new对象调用
2.在非静态方法中能直接访问静态成员嘛? 能
a.同类:
直接调用
类名调用
b.不同类:
类名调用
3.在静态方法中能直接访问静态成员嘛?能
a.同类:
直接调用
类名调用
b.不同类:
类名调用
4.在非静态方法中能直接访问非静态成员嘛?能
a.同类:
直接调用
new对象调用
b.不同类:
new对象调用
总结:
1.不管在不在同一个类中,非静态成员都可以new对象调用
2.不管在不在同一个类中,静态成员都可以类名调用
问题1:既然static成员那么好使(类名直接调用),那么我们在实际开发中,能不能将所有的成员都定义成静态的呢? 不能 原因:由于静态成员会随着类的加载而加载,如果将所有的成员都变成静态的,那么类一加载,静态成员都会进内存,会大量占用内存空间 问题2:那么静态成员都啥时候定义呢? 一般情况下,我们在抽取工具类的时候可以将工具类中的所有成员都定义成静态的 问题3:啥时候定义工具类? 比如我们在写代码的过程中,发现有的功能在反复实现,代码一样,功能一样,此时就可以抽取出来,形成工具类（代码复用）public class ArraysUtils { /* 构造方法用private修饰 工具类中的成员都是静态的,静态成员都是类名调用,不需要new对象 所以工具类中的构造方法都是用private修饰 如果构造方法被private修饰,那么在别的类中,就不能利用构造方法new对象 */ private ArraysUtils(){ } //定义一个方法,实现获取int数组最大值 public static int getMax(int[] arr){ int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (max<arr[i]){ max = arr[i]; } } return max; } }public class Test01 { public static void main(String[] args) { int[] arr = {5,3,4,6,7,54,8}; int max = ArraysUtils.getMax(arr); System.out.println("max = " + max); } }public class Test02 { public static void main(String[] args) { int[] arr = {5,4,5,7,8,9}; int max = ArraysUtils.getMax(arr); System.out.println("max = " + max); } }
第二章.可变参数
1.需求:
定义一个方法,实现n个整数相加
2.分析:
方法参数位置,只明确了参数的类型,但是不明确参数个数,此时就可以定义成可变参数
1介绍和基本使用
1.定义格式:
数据类型...变量名
2.注意:
a.可变参数的本质是一个数组
b.参数位置不能连续写多个可变参数,而且当可变参数和其他普通参数一起使用时,可变参数需要放到参数列表最后
public class Demo01Var {
public static void main(String[] args) {
sum(1,2,3,4,5);
sum1(1,1,2,3,4);
}
public static void sum(int...arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
System.out.println(sum);
}
public static void sum1(int i,int...arr){
}
}
1.1字符串拼接
需求一：返回n个字符串拼接结果，如果没有传入字符串，那么返回空字符串""
public class Demo02Var {
public static void main(String[] args) {
String result = concat("张无忌", "张翠山", "张三丰", "张三");
System.out.println("result = " + result);
}
public static String concat(String...s){
String str = "";
for (int i = 0; i < s.length; i++) {
str+=s[i];
}
return str;
}
}
需求二：n个字符串进行拼接，每一个字符串之间使用某字符进行分隔，如果没有传入字符串，那么返回空字符串""
比如:concat("-","张三丰","张翠山","张无忌") -> 返回 -> 张三丰-张翠山-张无忌
public class Demo03Var {
public static void main(String[] args) {
String result = concat("-", "张三丰", "张翠山", "张无忌");
System.out.println("result = " + result);
}
public static String concat(String regex, String... s) {
String str = "";
for (int i = 0; i < s.length; i++) {
if (i == s.length - 1) {
str += s[i];
} else {
str += s[i] + regex;
}
}
return str;
}
}
第三章.递归
1.概述:方法内部自己调用自己
2.分类:
a.直接递归
public static void method(){
method()
}
b.间接递归:
A(){
B()
}
B(){
C()
}
C(){
A()
}
3.注意:
a.递归必须要有出口,否则会出现"栈内存溢出"
b.递归即使有出口,递归次数不不要太多
public class Demo01Recursion {
public static void main(String[] args) {
method();
}
public static void method(){
method();
}
}
第四章.数组常见算法
1.数组翻转
1.概述:数组对称索引位置上的元素互换
public class Demo01Reverse {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7};
for (int min = 0,max = arr.length-1;min<max;min++,max--){
int temp = arr[min];
arr[min] = arr[max];
arr[max] = temp;
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
}
2.冒泡排序
数组的排序，是将数组中的元素按照大小进行排序，默认都是以升序的形式进行排序，数组排序的方法很多，我们讲解的是数组的冒泡排序。
排序，都要进行数组 元素大小的比较，再进行位置的交换。冒泡排序法是采用数组中相邻元素进行比较换位。
arr[i](前一个元素) arr[i+1](后一个元素)
2.1 代码实现
public class Demo02Bubble {
public static void main(String[] args) {
//定义一个数组,长度为5,最大索引为4
int[] arr = {5,4,3,2,1};
/*
第一圈
越界原因:当i变化到4的时候-> arr[4]>arr[5] -> 直接操作了5索引,所以越界了
越界解决:我们可以让arr.length-1
如果arr.length-1-> 比较就是i<4 -> 此时i最大可以变化到3
当i变化到3时 -> arr[3]>arr[4] -> 正好是最后两个元素进行比较
*/
/*for (int i = 0; i < arr.length-1-0; i++) {
if (arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}*/
//第二圈
/*for (int i = 0; i < arr.length-1-1; i++) {
if (arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}*/
//第三圈
/*for (int i = 0; i < arr.length-1-2; i++) {
if (arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}*/
//第四圈
/*for (int i = 0; i < arr.length-1-3; i++) {
if (arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}*/
/*
外层循环代表比较了几圈
n-1圈
*/
for (int j = 0; j < arr.length-1; j++) {
/*
内层循环代表每一圈比较的次数
每圈都少比较一次
*/
for (int i = 0; i < arr.length-1-j; i++) {
if (arr[i]>arr[i+1]){
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
}
}
3.二分查找
1.前提:数组中的数据必须是有序的
2.查询思想:
a.老式查询:遍历数组,一个一个比较 -> 查询效率慢
b.二分查找:每次找中间索引对应的元素进行比较查询(每一次查询少一半数据)
public class Demo03Binary {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9};
int index = binary(arr, 60);
System.out.println(index);
}
public static int binary(int[] arr,int data){
//定义三个变量,分别代表最大索引,最小索引,中间索引
int min = 0;
int max = arr.length-1;
int mid = 0;
//查找
while(min<=max){
mid = (min+max)/2;
if (data>arr[mid]){
min = mid+1;
}else if(data<arr[mid]){
max = mid-1;
}else{
return mid;
}
}
return -1;
}
}
第五章.对象数组
1.对象数组
1.需求:定义一个长度为3的数组,存储3个Person对象,遍历数组,将三个Person对象中的属性值获取出来
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Demo01ObjectArray {
public static void main(String[] args) {
/*
Person p = new Person();
1.定义一个存储int型数据的数组:int[]
2.定义一个存储double型的数组:double[]
3.定义一个存储String型的数组:String[]
4.定义一个存储Person型的数组:Person[]
*/
//定义数组
Person[] arr = new Person[3];
//创建三个对象
Person p1 = new Person("金莲",26);
Person p2 = new Person("涛哥",18);
Person p3 = new Person("张三",20);
//将三个对象保存到数组中
arr[0] = p1;
arr[1] = p2;
arr[2] = p3;
/*
遍历
当i = 0 arr[0] 就是 p1对象
当i = 1 arr[1] 就是 p2对象
当i = 2 arr[2] 就是 p3对象
*/
for (int i = 0; i < arr.length; i++) {
//Person p = arr[i];
System.out.println(arr[i].getName()+"..."+arr[i].getAge());
}
}
}
第六章.方法参数
1.基本数据类型做方法参数传递
基本类型做方法参数传递,传递的是值,不是变量本身
方法运行:压栈
方法运行完毕:弹栈 -> 释放栈内存
public class Demo01Param {
public static void main(String[] args) {
int a = 10;
int b = 20;
method(a,b);
System.out.println(a);//10
System.out.println(b);//20
}
public static void method(int a,int b){
a+=10;
b+=20;
System.out.println(a);//20
System.out.println(b);//40
}
}
2.引用数据类型做方法参数传递
引用数据类型做方法参数传递时,传递的是地址值
public class Demo02Param {
public static void main(String[] args) {
int[] arr = {10,20};
method(arr);
System.out.println(arr[0]);//20
System.out.println(arr[1]);//40
}
public static void method(int[] arr){
arr[0]+=10;
arr[1]+=20;
System.out.println(arr[0]);//20
System.out.println(arr[1]);//40
}
}
第七章.命令行参数(了解)
通过命令行给main方法的形参传递的实参称为命令行参数
public class TestCommandParam{
//形参：String[] args
public static void main(String[] args){
for(int i=0; i<args.length; i++){
System.out.println("第" + (i+1) + "个参数的值是：" + args[i]);
}
}
}
运行命令：
java TestCommandParam
java TestCommandParam 1 2 3
java TestCommandParam hello atguigu
第八章.其他操作
1.快速生成方法
1.初学者要求先定义,再调用;不是初学者,就可以先调用,再定义方法
a.快捷键:alt+回车
2.快速将一段代码抽取到一个方法中:
a.选中要抽取的方法
b.按ctrl+alt+m
2.debug调试
1.概述:调试代码的一种手段
2.作用:
a.能清楚的看到每个变量在代码执行过程中的变化
b.找错
3.使用:
a.在想要开始debug的那一行左边点击一下,出现红色小圆点(断点)
b.右键-> 点击debug