Java-day01
=================
****
第一部分
-------
1.认识java
2.安装java环境
JVM:java虚拟机,每一个平台都有一个虚拟机.他是实现java跨平台的基础,虚拟机就是一个虚拟的主机.
（JVM调优问题参考https://www.cnblogs.com/csniper/p/5592593.html）
JRE:包含JVM和核心类库,所以有了jre就可以运行基本的java程序
JDK:软件开发工具包,包含常用的软件开发工具和jre,所以有了jdk可以进行大型java程序的开发
所以总结一句:只要安装jdk即可
3.常用的终端命令
cd 打开
cd .. 返回上一层目录
dir 查看当前目录的内容
cls 清屏
ipconfig 查看当前主机的网络内容
c: 切换盘符
vi:编辑
:wq! 保存并强制退出
4.一个程序运行需要的两个基本指令 javac.exe java.exe
一个java程序从开始到得到结果,最基本的两个过程:编译和运行
javac 1.javac命令表示编译，将java源文件编译成字节码文件:class; javac hello.java
java 2.java命令表示解释和运行字节码文件：java hello
5.环境变量的配置
目的:将一些文件的路径系统化,可以直接调用文件名执行文件
方法:我的电脑-属性-高级系统设置-环境变量-系统变量-新建
变量名:JAVA_HOME 变量(环境变量/路径):具体的路径 C:\Program Files (x86)\Java\jdk1.8.0_31\
进入Path:添加 %JAVA_HOME%\bin %JAVA_HOME%\lib
**********
第二部分---主要内容
---------
java基本语法
1.常量
2.变量
3.注释
4.关键字
5.标识符
6.数据类型
7.进制转换
8.运算符
流程控制语句
if
switch case
dowhile
while
for
函数
//注释:进行解释说明的文字,不参与编译
//1.class,public,static,void都是关键字
//2.关键字:被java赋予了特殊含义的单词,我们只能使用,不能改变.
//3.class:类的意思,类是java工作的基本单元
//4.{}是范围的意思,成对出现
//5.默认.java文件的名字与.class文件的名字无关
//6.一个类对应的一个.class文件,并且.class文件的名字与类名一致
//7.一个.java文件中可以放多个类,但是只能放一个被public修饰的类.
//8.我们把public修饰的类称为主类,一般main写在主类里
第三部分--代码Demo与主要课程内容
------
Demo1:
package com.qf.test;
//一般在一个.java文件中只放一个类
//一个类的全称是包名+类名
public class Demo1 {
//程序的入口
public static void main(String[] args) {
System.out.println("hello world");
}
}
Demo2: 注释与cup磁盘存储与命名规则与数据类型进制转换
package com.qf.test;
public class Demo2 {
/**
* 文档注释
* @程序的入口
*/
/**
* cpu计算
* 内存与磁盘是存数据的
* cpu计算快 磁盘存储慢 内存存储快
* 内存是磁盘与cpu之间的一个过渡
* 内存：短存储
* 磁盘：长期存储
* IO流是以内存为中心
*/
public static void main(String[] args) {
//1.关键字:是被java赋予了特殊含义的单词,咱们只能用不能改,也不能跟这些关键字重名
//举例:class 类 public:权限(公共的) static:静态的 void :空的 package:导包
//2.标识符:程序中需要我们自己命令的
//不能跟关键字重名
//标识符中只能包含字母,数字,_和$
//区分大小写 A a
//不能以数字开头
//注意:可以使用中文作为标识符,但是一般不使用.
//正确的: abc aBc a444 $aa ___ 你好 错误的: 44d class
//3.注释:解释说明的,不参与编译
//单行注释 control+/
/*
* 多行注释 control+shift+/
*/
/**
* 文档注释,当我们将鼠标放在对应的方法上,会将注释的信息显示出来
*/
//4.常量:固定不变的量
//分类:整数常量 44 555 小数常量 4.5 5.6 字符常量 'a' 'b' 字符串常量 "hello" 布尔常量 true false
//5.变量:存储程序中用到的数据,它存储的数是可以改变的,只能存储一个数
//6.数据类型：规范变量的内存空间
//分类:第一种分法是根据数据类型分.
/*
* 第一:基本数据类型
* 数值型 范围
* >byte型 1个字节 [-2^7,2^7-1]
* >short型 2个字节 [-2^15,2^15-1]
* >int 4个 [-2^31,2^31-1]
* >long 8个 [-2^63,2^63-1]
* 布尔型
* >boolean 1个
* 浮点型(小数)
* >float 4个
* >double 8个
* 字符型
* >char 1个
* 第二:引用数据类型(暂时先不讲)
* 数组,类,接口等
*
*
* 根据有无符号分类:一般我们研究的是有符号型.
* 有符号型的:有正负0之分
* 无符号型:只有正0,没有负数
*/
//字节(计算机数据的存储单位) b B kB MB GB TB PB
//进制转换:进制:看遇几进一,就是几进制
/*
* 常用进制:
* 二进制:是计算能够识别的进制
* 八进制:是辅助二进制运算和存储的.
* 十进制:是人类能够识别的
* 十六进制:是辅助二进制运算和存储的.
*/
//负数的二进制形式说明
//计算机中存储负数存储的是它的补码 可以通过取反加一获得源码
//数据类型的作用:通过它可以确定一个变量的大小以及类型,通过使用数据类型可以更加高效的利用内存.
//通常我们将使用过程这样描述: int a; byte b;
/*
* 数据类型的实际使用
*/
//数组型
/*
* 区别:
* 初始化:只有在定义的时候完成的赋值才叫初始化
* 赋值:
*/
byte a = 12; //定义了一个byte类型的变量a,并初始化成12
a = 56;//给a重新赋值成56
//a = 129;//超出了一个有符号型的byte类型的范围,所以出错了.
short b = 34;
int c = 44;
int d;
d = a;//自动类型转换
a = (byte)c;//强制类型转换
//7.类型转换
//类型的高低是根据数据类型表示的数范围的大小确定的.
//自动类型转换 :数据类型从低类型转成高类型,没有数据的损失
//强制类型转换:数据类型从高类型转成低类型,有可能会出现数据的损失.
byte g = 126,h; // g:01111110
short gg = 129,hh; // gg:00000010 10000001
h = (byte)gg;//强制类型转换 ,这里会将short型高位的字节砍掉,剩下的就是 10000001 -127
hh = g;//自动类型转换,转换后得到的两个字节是 00000000 01111110
/*
* +号的作用
* 1.计算
* 2.连接字符串,当+号两边有一个是字符串,+号的作用就变成了连接
*/
System.out.println("h:"+h+" hh:"+hh);
//类型转换举例
//注意:一个整数默认是int型的
byte t = 10;
byte y = (byte)(t + 3);
//8.数据类型的一些其他内容
//布尔型:他只有两个值true/false;在java中boolean只能取true/false,但是在c中可以取0和非零.0代表false,非零代表true.
boolean bbb = true;
//浮点型,一个小数默认是double型
float ff = 4.5f;//需要在数的后面加f
double ddd = 4.5;
//字符型 字符是'' 字符串是""
char cc = 'a';//注意''中只能写一个字符
//9.char相关的内容
/* char 1个字节,默认对应的语言是英文,字符集是ASCII 0-48 A-65 a-97
* 针对中文: 对应的字符集是GBK/GB2312 一个汉字2个字节
* 常用的字符集: GBK(中国标准) UTF-8(国际通用标准) ASCII(国标) uncode(内部编码) ISO8859-1(欧洲标准)
* 对于中文: 2个字节 3个字节 不支持中文 2个字节 不支持中文
* 我们通常把字符串转成二进制的过程称为编码
* 将二进制转成字符串的过程称为解码
* 计算机存储的是字符集对应值的二进制
*/
int uu = cc + 1;
System.out.println((int)cc+" uu:"+(char)uu );
//10.数据类型高低排序
long maxLong = Long.MAX_VALUE;
float maxFloat = Float.MAX_VALUE;
//float最大值比long的最大值大很多，相减时long值可以忽略不记
System.out.println(maxFloat-maxLong+" maxFloat:"+maxFloat+" maxDouble:"+Double.MAX_VALUE);//3.4028235E38
//确定数据类型的优先级,从低到高
//char,byte-short-int-long-float-double
}
}
变量的内存展示
Java存储的堆栈方法区的区别 内存有 ：栈 堆 方法区 静态方法区 寄存器 五部分
数组的内存
计算机数据的存储
数据类型·
进制转换
负数的二进制
Demo3: 运算符
package com.qf.test;
public class Demo3 {
public static void main(String[] args) {
/*
* 运算符:
* 分类:
* 第一:根据类型分类
* 算数运算符:+ - * / % ++(自增) --(自减)
* 赋值运算符:= += -= *= /= %= ^=
* 逻辑运算符:&& || !
* 关系运算符:== < <= > >= !=
* 位运算符:操作位的. & | ^ ~
* 移位运算符:操作位的. >> << >>>
* 第二:根据操作元素个数分类
*/
// * 算数运算符:+ - * / % ++(自增) --(自减)
System.out.println(-3/-2);//计算机中的乘除法与普通的运算一样
System.out.println(-3%-2);//余数的符号与被除数一致
//++(自增): --(自减)
int a =2,b =2,c=3,d=1,x,y;
x = a++;//变量先参与运算,再自己增加1
y = ++b;//变量先自己增加1,再参与运算
System.out.println("x:"+x+" a:"+a+" y:"+y+" b:"+b);
// * 赋值运算符:= += -= *= /= %= ^=
c = 4;
c += 5;//相当于 c = c+5;
int q;//注意:变量必须先赋值后使用
//q += 4;//q = q+4;
// * 关系运算符:== < <= > >= !=
//特点:结果一定是boolean值.
System.out.println(3 == 4);
// * 逻辑运算符:&&(逻辑与) ||(逻辑或) !(逻辑非)
//特点:1.结果一定是boolean型的值 2.运算符两边的元素也必须是boolean型的值
//逻辑与:一假则假,全真才真 逻辑或:一真则真,全假才假
boolean bool = false;
bool = !bool;
System.out.println(bool+" "+ !true);
System.out.println(true && false);//false
System.out.println(true || (5>6));//true
System.out.println((4<7) && false && false );//false
/*
* 短路与:当一个式子中有多个连续的&&,我们只需要找出第一个false,即可停止运算.因为只要有一个false,整体结果就是false
* 短路或:当一个式子中有多个连续的||,我们只需要找出第一个true,即可停止运算.因为只要有一个true,整体结果就是true
*/
/*
* 问题总结:
* 以短路&&做例子
* 1.当遇到false的时候,是否停止运算?
* 是
* 2.对于连续的&&或者连续的||会使用短路&& 与短路||,但是如果一个式子中同时出现了连续的&&和||,什么情况?
* 只有连续的部分遵守对应的规则,之后会用整体的结果参与后面的运算
* 3.逻辑运算符的两边只允许使用true或false
*/
int n=2,m=1,w=1;
boolean b3 = true && false && n++>0;
System.out.println("n:"+n);//2
boolean b4 = true && false && w++>0 || m++<0 ;
System.out.println("w:"+w+" m:"+m);//w:1 m:2
}
}
//复杂的运算先找优先级最低的然后考虑结合性,以此类推直到找到优先级最大的然后往回算
运算符的优先级
Demo4:
package com.qf.test;
public class Demo4 {
public static void main(String[] args) {
/*
* 位运算符:直接作用于位的
* 作用:因为我们直接操作的位,可以提高计算的效率
* &(按位与):全1则1,有0则0: 作用:定向清0
* |(按位或):全0则0,有1则1
* ^(按位异或):相同则0,不同则1
* ~(按位取反):1则0,0则1
*/
int a = 4,b=5;
/*
* 0100 4
* 0101 5 &
* 0100 4
*
* 作用:定向清0 让IP于子网掩码做按位与操作,来确定IP的网段
* 192.168.1.123 IP
* 255.255.255.0 子网掩码
* 192.168.1.1 网关
*
*
* 0100
* 0101 |
* 0101 5
*
* 0000 0100 ~
* 1111 1011 结果-5 正数的取反的到负数的补码 计算机中存储的是数字的补码
*
* 0100
* 0101 ^
* 0001 1
* 作用:交换两个数的值
*/
//第一种交换值:借助于三方变量
int c = 0;
c = a;
a = b;
b = c;
System.out.println("a:"+a+" b:"+b);
//第二种交换值:借助于^
a = a ^ b;
b = a ^ b;
a = a ^ b;
/*
* 0101 a
* 0100 b
* 0001 a 1
*
* 0001 a
* 0100 b
* 0101 b 5 最终的b值
*
* 0001 a
* 0101 b
* 0100 a 4 最终的a值
*/
System.out.println("a:"+a+" b:"+b);
/*
* 移位运算符 >> 有符号右移 << 有符号左移 >>> 无符号右移
* >>1 右移一位:代表除以2
* <<1 左移一位:代表乘以2
*
* 注意:先左移后右移或者先右移再左移之后,不一定得到原来的结果
* 作用:直接操作的位,效率会高
*/
/*
* 原始 00000101
* 移动后 0 0000010 1 最后的1被删除了
* 移动后 000001010 最后的0是补上的
*/
System.out.println(5>>1);
System.out.println(5<<1);
/*
* 按照操作的元素个数分:
* 一元运算符: ++ -- -(正) +(负) ! ~
* 二元运算符:
* 三元运算符: ?:(三目运算符)
*/
/*
* ?:(三目运算符)
*
* 表达式:由多个变量和运算符组合在一起的式子
* 语句:表达式+;,窒息的一个;是空语句
* 构成: 条件 ? 结果一:结果二
* 原理:当作为条件的表达式的结果为true,整个三目元算符的结果就是结果一,否则就是结果二
*/
//举例:求两个数的最大值
int x = 4,y =6;
int z = x>y?x:y;
System.out.println(z);
}
}
Demo5: 流程控制语句
package com.qf.test;
public class Demo5 {
public static void main(String[] args) {
/*
* 流程控制语句:顺序,分支,循环
* 分支:
* if{} if{} else{} if{} else if {} if{ if{} else{} } switch case
if(判断条件(true/false)){
执行的语句;
}
if(true){
执行语句1;
}else{
执行语句2;
}
if(条件1){
执行语句1;
}else if(条件2){
执行语句2;
}else if(条件3){
执行语句3;
}else{
执行语句4;
}
if(true){
if(true){
执行语句1;
}else{
执行语句2;
}
}
int a = 3;
switch(a){
case 1:{执行语句1; }
break;//是结束的意思
case 2:{执行语句2; }
break;
case 3:{执行语句3; }
break;
case 4:{执行语句4; }
break;
default:{执行语句5; }
break;
}
c:循环结构 while do while for
三要素:1.判断(起始)条件 2.结束条件 3.自增量的设置
whlie(条件){
执行语句2
}
int i=1;
whlie(true){
i++;
if(i == 5){
break;
}
}
执行语句3
int shangke = 180;
while(shangke>1){
shangke--;
System.out.println("ok");
}
System.out.println("循环结束");
do{
执行语句2;
}while(条件);
执行语句3
//dowhile 与while的区别:就是dowhile不管条件成立与否,语句都会先执行一次
//for
for(定义的初始值;结束的条件;自增量(变化量))
{
执行语句;//循环体
}
*/
}
}
流程控制图
Demo6:
package com.qf.test;
public class Demo6 {
public static void main(String[] args) {
//实例:判断当前的月份属于哪个季节
//季节:春季 3,4,5 夏季 6,7,8 秋季 9,10,11 冬季 12,1,2
//使用if
int value = 4;
if (value == 3) {
System.out.println("春");
}else if (value == 4) {
System.out.println("春");
}else if (value == 5) {
System.out.println("春");
}else if (value == 6) {
System.out.println("夏");
}else if (value == 7) {
System.out.println("夏");
}else if (value == 8) {
System.out.println("夏");
}else if (value == 9) {
System.out.println("秋");
}else if (value == 10) {
System.out.println("秋");
}else if (value == 11) {
System.out.println("秋");
}else {
System.out.println("冬");
}
//优化代码一
if (value == 3 || value == 4 || value == 5) {
System.out.println("春");
}else if (value == 8 || value == 7 ||value == 6) {
System.out.println("夏");
}else if (value == 9 || value == 10 || value == 11) {
System.out.println("秋");
}else {
System.out.println("冬");
}
//优化代码二
/*
* 平时计算 5<a<6 a<5或者 a>6
* 在计算机中 a>5 && a<6 a<5 || a>6
*/
if (value >=1 && value <= 12) {
if (value >= 3 && value <= 5) {
System.out.println("春");
}else if (value >= 6 && value <= 8) {
System.out.println("夏");
}else if (value >= 9 && value <= 11) {
System.out.println("秋");
}else {
System.out.println("冬");
}
}else {
System.out.println("你输入的值超出了正常的范围");
}
//注意点:
//正确的:适合于跟多条语句
if (value == 4) {
System.out.println("ok");
System.out.println("uaua");
}
//正确的:适合于跟一条语句
if (value == 4)
System.out.println("ok");
//他跟if没有关系
System.out.println("uaua");
//正确的:跟了一个空语句
if (value == 4);
//利用switch实现实例
//注意点:1.break:是结束switch 的意思,我们把当忘记写break时出现的情况称为switch的穿透性.
//2.switch后面()中的可以取的值:整型,字符串(从jdk1.7开始使用),字符,枚举
int a = 4;
switch (a) {
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("冬");
break;
}
}
}
Demo7:
package com.qf.test;
public class Demo7 {
public static void main(String[] args) {
/*
* 循环语句:for dowhile while
* 循环的三要素:
*
* 1.起始条件
* int num = 1;
*
* while(判断条件){//2.结束条件
* 执行语句;
* 3.自增量(变化值)
* num+=2;
* }
*
* 语句2;
*/
//实例:利用while求1-10的和,当num是5的时候,结束打印(break),当num=3的时候,跳过这次循环,继续执行下面的循环
int num = 1;
int sum=0;
while (num<=10) {
sum+=num;
System.out.println(num);
if (num == 5) {
break;//跳出整个循环的意思
}
num++;
if (num ==3) {
continue;//跳出当前次循环的意思
}
}
System.out.println(sum);
//dowhile
int m = 1;
int sum1 = 0;
do {
sum1+=m;
m++;
} while (m<=10);
System.out.println("sum1:"+sum1);
//dowhile与while的区别:do里面的代码,不管while的条件是否成立,都会首先执行一次.
//所以dowhile适合用于初始化
/*
* for循环
* for(起始条件;结束条件;自增量){//循环体
* 执行语句;
* }
* 原理:1.会执行起始条件
* 2.判断结束条件,有两种情况:第一种不成立,直接结束循环.第二种成立,就去执行循环的语句
* 3.执行自增量
* 4.继续执行结束条件,依次反复进行,直到结束条件不成立,结束循环
*
* 起始条件:肯定执行一次
* 结束条件:至少一次
* 自增量:0次或多次
* 执行语句:0次或多次
*/
int sum2 = 0;
for(int i=1;i<=10;i++) {
sum2+=i;
if (i==3) {
continue;
}
if (i==5) {
break;
}
}
System.out.println(sum2);
//注意点:
//1.for与while的区别:在循环中是否使用i值.使用i值就使用for,不用i值就使用while
//2.for后面也可以跟;
for(int i=1;i<=10;i++);
//3.防止出现死循环,如果出现了死循环,下面的代码无法执行
for(;;) {
break;
}
//4.循环可以嵌套,可以给for循环添加标识,我们可以认为是给他起了一个别名.
//提问:当i=2,j=3的时候将整个的二层循环结束
n:for(int i=1;i<=4;i++) {
m:for(int j=1;j<=4;j++) {
System.out.println("i:"+i+" j:"+j);
if (i==2 && j==3) {
break n;
}
}
}
}
}
Demo8:
package com.qf.test;
public class Demo8 {
public static void main(String[] args) {
//要求一次只能打印一个*
/*
* *****
* *****
* *****
* *****
* *****
*/
for (int i = 0; i < 5; i++) {//行数
for(int j=0;j<5;j++) {//一行*的个数
// System.out.println("*");//打印+换行
// System.out.println();//换行
System.out.print("*");//不换行打印
}
System.out.println();
}
/* 行数 个数
* * 1 1
* ** 2 2
* *** 3 3
* **** 4 4
* ***** 5 5
*/
for (int i = 1; i <= 5; i++) {//行数
for(int j=1;j<=i;j++) {//一行*的个数
System.out.print("*");//不换行打印
}
System.out.println();
}
//练习1:打印99乘法表 '\t'制表符
public static void main(String[] args){
for(int i=1; i<=9; i++) {
for(int j=1; j<=i; j++) {
System.out.print(j+"*"+i+"="+j*i+"\t");
}
System.out.println();
}
}
//练习2
/*
* &&&*
* &&***
* &*****
* *******
*
* *****
* ***
* *
*/
public static void main(String[] args){
for(int i=3;i>=0;i--) {
for(int j=1;j<=i;j++) {
System.out.print("&");
}
for(int k=1;k<=7-2*i;k++) {
System.out.print("*");
}
System.out.println();
}
for(int i=3;i>=1;i--) {
for(int j=0;j<=3-i;j++) {
System.out.print(" ");
}
for(int k=1;k<=2*i-1;k++) {
System.out.print("*");
}
System.out.println();
}
}
//练习3
/*
* *
* * *
* * *
* * *
* * *
* * *
* *
*/
public static void main(String[] args){
for(int i=3;i>=0;i--) {
for(int j=1;j<=i;j++) {
System.out.print(" ");
}
for(int k=1;k<=7-2*i;k++) {
if(k==2*(4-i)-(7-2*i)) {
System.out.print("*");
}else if(k==7-2*i) {
System.out.print("*");
}else {
System.out.print(" ");
}
}
System.out.println();
}
for(int i=3;i>=1;i--) {
for(int j=0;j<=3-i;j++) {
System.out.print(" ");
}
for(int k=1;k<=2*i-1;k++) {
if(k==2*i-1) {
System.out.print("*");
}else if(k==2*i-(2*i-1)) {
System.out.print("*");
}else {
System.out.print(" ");
}
}
System.out.println();
}
}
}
Demo9: 函数
package com.qf.test;
import java.util.Scanner;
public class Demo9 {
public static void main(String[] args) {
// 函数：对某一有特殊功能代码的封装
/*
* 求两个数的和
*
函数的构成:
* 修饰词 返回值类型 函数名(参数列表){
* 函数的功能代码;
* return 返回值;
* }
* 修饰词:限定当前函数的可见范围的,暂时先忽略
* 返回值类型:可以有,也可以没有,如果没有需要些void
* 函数名:必须有,命名规则:遵循小驼峰原则(当有多个单词组成名字的时候,除第一个单词外,所有单词的首字母大写)
* 函数名:要做到见名知意
* 参数列表:1.可以有,可以没有 2.如果有,可以有一个或多个,多个参数之间以,隔开
* return 返回值; 这里是一个动作,后面放的是要返回的数据,要求:返回值类型要与return后面的类型一致
* 注意点:return后面只能放一个数据
* 特点:有结束的意思
*
* 注意:函数之间可以调用,但是不能嵌套
*/
//函数的调用:通过函数的名字发生的调用
mysum();
mysum();
}
public static void mysum(){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个数:");
int num1 = scanner.nextInt();
System.out.println("请输入第二个数:");
int num2 = scanner.nextInt();
int sum = num1+num2;
System.out.println(sum);
}
}
Demo10:
package com.qf.test;
//import是导入的意思,这里会将Scanner内部的代码读取一遍.
import java.util.Scanner;
/*
* 注意点:
* 1.if,for等可以嵌套.但是函数的定义不能嵌套,调用可以.
* 2.函数的功能必须通过调用实现
* 3.函数有功能单一性原则.即一个函数中最好只有一个功能.
* 4.函数的作用:可以提高程序的安全性,复用性,健壮性,可读性,节省内存.
*/
public class Demo10 {
public static void main(String[] args) {
//函数的调用
mySum();
}
//函数的定义:有函数的具体功能实现.
public static void mySum(){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个数:");
int num1 = scanner.nextInt();
System.out.println("请输入第二个数:");
int num2 = scanner.nextInt();
int sum = num1+num2;
System.out.println(sum);
}
}
Demo11:
package com.qf.test;
//import是导入的意思,这里会将Scanner内部的代码读取一遍.
import java.util.Scanner;
/*
* 注意点:
* 3.函数有功能单一性原则.即一个函数中最好只有一个功能.
1)直接定义在函数,for,if等中的变量称为局部变量.
局部变量只在他所在的函数,for,if中可见可用.出了这个范围就会从内存中消失.
2)我们把函数定义处的变量称为形参:形式上的参数
把函数调用处的变量称为实参:实际的参数
形参必须通过接受实参的值才能起作用.
我们在定义形参和实参时注意:
参数的个数要一致
参数的位置要一致
参数的类型要一致
3)return注意点:
返回数据,将数据往外抛
结束的意思,在表示结束时,函数不一定有返回值.
*/
public class Demo11 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个数:");
int num1 = scanner.nextInt();
System.out.println("请输入第二个数:");
int num2 = scanner.nextInt();
//函数的调用
//当调用函数时,函数调用处的参数会自动的赋值给函数定义 处的参数(隐藏代码)
int sum1 = mySum(num1,num2);//实参
System.out.println(sum1);
}
//函数的定义:有函数的具体功能实现.
//外界直接接受的是返回值类型处的值.
//返回值类型和return后面要一致.
public static int mySum(int a, int b){// a = num1 b = num2 形参
int sum = a+b;
return sum;//将数据抛出
}
//return注意点:
//返回数据,将数据往外抛
//结束的意思,在表示结束时,函数不一定有返回值.
public void test(int a) {
System.out.println("haha");
if (a == 5) {
return;
}
System.out.println("hehe");
}
//要保证任何情况下都要有返回值.
public int test1(int a) {
System.out.println("haha");
if (a == 5) {
System.out.println("下课");
return a;
}else {
System.out.println("上课");
return a;
}
}
}
Demo12:
package com.qf.test;
/*
* 全局变量:直接定义在类中的变量
* 局部变量:直接定义在函数,for,if等中的变量称为局部变量.
*
* 比较 作用范围 (作用域) 默认值
* 全局变量 整个的类 在不赋值时,是有默认值.
*
* 局部变量 从定义变量开始到所在的方法,if等结束 必须现赋值后使用,没有默认值
*
*/
/*
* 全局变量在堆区,与它的类一致
* 局部变量在栈区
* 对象在堆区
* 函数在栈区
*/
public class Demo12 {
int b;//全局变量
public static void main(String[] args) {
int a = 5;//局部变量
}
public void test() {
System.out.println(b);//可以
//System.out.println(a);//不可以
}
}
函数在内存中的表现
Demo13:
package com.qf.test;
public class Demo13 {
/*
* java将内存分成了5块儿,分别是堆区,栈区,方法区,本地方法区,寄存器
* 栈区:里面存放数据的特点是:先进后出,我们主要将局部变量和函数放在栈区,数据的特点是使用完立刻释放
* 堆区:存放的是实体(对象和数组),实体可以同时存放多个值,实体里面的变量如果不赋值,会有默认值.整型数据默认值是0,boolean---false
*
* 了解:
* 堆区中的数据会在某个时刻被释放-通过垃圾回收机制.
* 垃圾回收机制是通过一个线程控制的,由于这个线程的等级比较低,所以不会立刻执行,数据就不会立刻释放.
*/
public static void main(String[] args) {
//实例:使用函数求两个数的最大值
int num1 = 4,num2 = 5;
int maxValue = max(num1,num2);
System.out.println(maxValue);
}
public static int max(int a,int b) {
int maxValue = a>b?a:b;
return maxValue;
}
}
Demo14:
package com.qf.test;
/*
* 对于函数:java内部识别时,真正识别的是函数名字+参数类型的列表 例如: sum_int_float
* 函数的重载:在同一个类中,方法名相同,参数不相同的方法的关系
* 重载的功能：为这种方法提供多种可能性
* 注意点:
* 1.参数的个数不同是重载
* 2.参数的类型不同是重载
* 3.参数的位置不同是重载
* 4.重载与返回值无关
* 5.重载与参数的名字无关
* 6.重载的方法本质上还是不同的方法.
*/
public class Demo14 {
public static void main(String[] args) {
}
//1
//求两个数的和
public int sum(int a,int b) {//sum_int_int
int sum = a+b;
return sum;
}
//2与1是重载,参数的个数不同
//求三个数的和
public int sum(int a,int b,int c) {//sum_int_int_int
int sum = a+b;
return sum;
}
//3与1是重载,参数的类型不同
public float sum(int a,float b) {//sum_int_int
float sum = a+b;
return sum;
}
//4与1不是重载,是同一个函数.这里只是参数的名字相同.
// public int sum(int a,int c) {//sum_int_int
// int sum = a+b;
// return sum;
// }
//5与1不是重载,这是错误.
// public float sum(int a,int b) {//sum_int_int
// int sum = a+b;
// return sum;
// }
//6与3是重载,参数的位置不同
public float sum(float a,int b) {//sum_int_int
float sum = a+b;
return sum;
}
}
Demo15:
package com.qf.test;
/*
* 明天的内容:
* 1.数组
* 2.二维数组
* 3.排序
* 4.查找
* 5.面向对象
*/
public class Demo15 {
public static void main(String[] args) {
test1();
}
static void test1() {
test2();
System.out.print("a");
}
static void test2() {
System.out.print("b");
test5();
}
static void test3() {
System.out.print("d");
test4();
}
static void test4() {
System.out.print("e");
}
static void test5() {
test3();
System.out.print("c");
}
}
扫一扫
5256
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
