1.Java SE 标准版
支持桌面级应用 也成为J2SE
1.2Java EE 企业级
该技术包含的技术有servlet jsp等,也称J2EE
1.3Java ME
现在用的较少了,面向移动端的.
1.Java是面向对象的(oop).
Java是健壮的,例如强类型机制,异常处理 垃圾的自动回收等是Java程序健壮性的重要保证.
3.Java是跨平台:编译成class文件,既可以在windows上运行,也可以在linux运行,具有跨平台性(底层具有虚拟机,jvm.)
4.Java是解释型的
解释型语言有:javascipt ,php,java 编译性语言:c/c++
4. 解释性语言编译后的代码不能直接被直接机器执行,还需要解释器来执行,而编译性语言在编译后,是可以直接执行的.
因为有了JVM，同一个Java程序在三个不同的操作系统中都可以执行
这也就实现了Java的跨平台性
Java的核心机制->Java虚拟机(Java vitral machine)
JVM是一个虚拟的计算机,具有指令集并使用不同的存储区域,负责执行指令,管理数据,内存,寄存器,它包含在JDK中.
不同的平台有不同的虚拟机
Java虚拟机机制屏蔽了底层运行平台的差别,实现了"一次编译,到处运行"
1. JDK: ( Java Development Kit Java 开发工具包)
JDK= JRE+ java的开发工具( java, javac, javadoc, javap等)
JRE基本介绍:
JRE: ( Java Runtime Enviroment Java 运行环境)
JRE= JVM+ Java 的核心类库( 类)
小结:
JDK= JRE+ 开发工具集( javac, java等)
JRE= JVM+ Java SE标准类库( Java 核心类库)
JDK= JVM+ Java SE标准库+ 开发工具集
使用sublime编写java,当你的代码中有中文时,一定要把字符集转换为GBK
.java文件:称为源文件
.class文件:字节码文件
5.2什么是编译:
java Hello.java
有了java源文件,通过编译器将其编译成JVM可以识别的字节码文件
在该源目录下,通过javac编译工具对Hello.java文件进行编译.
编译如果成功之后,没有任何提示,并在当前目录下会出现一个Hello.class文件.
该文件称为字节码文件,也是可以执行的java的程序.
5.3什么是运行?
有了可运行的java程序(Hello.class文件)
通过运行工具java.exe对字节码文件进行执行,本质就是.class文件装载到jvm机执行
注意:对修改后的Hello.java源文件需要重新进行编译,生成新的class文件后,再进行执行,才能生效!!
1.Java源文件以 .java为扩展名,源文件的基本组成部分是类(class),如本类中的Hello类
2.Java应用程序的执行入口是main()方法,它有固定的书写格式:
public static void main(String[] args){...}
3.Java语言严格区分大小写.
4.Java方法由一条条语句构成,每个语句以";" 结束.
5.大括号都是成对出现的,缺一不可.
6.一个源文件中最多只能有一个public类,其它类的个数不限.
7.如果源文件包含一个public类,则文件名必须按照该类名命名.
例如 源文件为: public class Hello{
public static void main(String[] args){...}
}
则这个文件的名称和后缀名必须为Hello.java
8.一个源文件中最多只能有一个public类,其它类的个数不限,也可以将main方法写在非public类中,然后指定运行非public类,这样入口文件就是非public的main方法.
例如一个源文件中有public类Hello,还有非public的类Dog和Trigger
public class Hello{
....("hello");
}
class Dogs{
....("Dog");
}
class Trigger{
....("Trigger");
}
然后将源文件编译:
javac Hello.java
输出三个后缀名为class的字节符文件.
为: Hello.class Dogs.class Trigger.class
当你想输出谁的main函数时,直接:
java Dogs.class
输出: Dog
java Trigger.class
输出:Trigger
注意:在命令窗口执行java xxx时,这个类必须有主方法,没有会报错!
exit:退出
cls:清楚屏幕
dir:列出目录下所有的子目录
cd 目录:进入某个目录
1.单行注释//
多行注释 /**/
javadoc注释:
/**
*
*
*
*/ =>可以生成帮助文档.
什么是标识符?
在源程序中程序员有权利自己有权利命名的单词都是标识符
标识符可以标识什么元素呢?
类名
方法名
变量名
接口名
常量名
2.标识符的命名规则?
2.1所有的标识符只能由数字 字母 下划线 美元符号组成,不能含有其它符号
不能以数字开头.
2.2严格区分大小写
2.3关键字不能做标识符
2.4理论上无长度限制
3.标识符的命名规范[不属于语法.不遵守规范,不会报错]
最好见名知意
尊守驼峰命名方式 UserName...
类名、接口名: 首字母大写,后面每个单词字母大写
变量名、方法名: 首字母小写,后面每个单词首字母大写
public static void doSome(){
int i = 10;
}
常量名: 全部大写
字面值: 100,'zbc',true...相当于c语言中的常量!
字面值是java程序的组成部分之一,包括标识符和变量名.
字面值也分了很多类:
整数型字面值
浮点型字面值
布尔型字面值
"abc"/"中国人" :字符串型字面值
'A'/'V' :字符型字面值(字符型:单引号中只能存放单个字符)
注意:java语言中所有的字符串字面值必须使用双引号括起来"",
java语言所有的字符型字面值必须使用单引号括起来''.
1.什么是变量?
本质上是内存中的一块空间,里面包括数据类型,名字,字面值.
变量是内存中存储数据的最基本的单元.
2.数据类型的作用?
不同的数据有数据类型,不同的数据类型底层分配不同大小的空间
3.变量要求:变量中存储的数据必须和变量的数据类型一致,不一致报错.
4.声明变量的语法格式:
数据类型 变量名;
数据类型:int
变量名: 首字母小写,后面单词首字母大写;
例:
int i; int num; int numSum;
5.变量声明之后怎么赋值?
语法格式:
变量名 = 字面值;
要求:字面值的数据类型必须和变量的数据类型一致.
赋值运算先运算等号右边的表达式,表达式执行结束后的结果赋值给左边的变量.
6.声明和赋值可以放到一起完成.
int i = 20;
7.变量赋值后可以重新赋值,值可变化.
8.通常访问一个变量包括两种访问的形式.
第一:读取变量中保存的具体数据
第二:修改变量中保存的具体数据
9.变量在一行上可以声明多个.
int i,a,b,c;
10.变量必须先声明,再赋值,才能访问.
1.方法体中的Java代码是遵守自上而下的顺序依次执行的,
方法体中,上面没有执行完,不会往下走.
在同一个作用域中,变量名之间不同同名,但可以重新赋值.
2.变量的作用域:
什么是作用域?
变量的有效范围.出了这个范围,就访问不到了.
在指定范围内是可以被访问到的.
简单来说,出了大括号就不能访问了.
例:
public static void main(String[] args){
int i = 0;
}
public static void doSome(){
System.out.println(i);//报错
}
3.变量的分类:
根据变量声明的位置来分类.
局部变量:
在方法体当中声明的变量叫做局部变量
成员变量:
在方法体外(类体内)声明的变量叫做成员变量
注意:在不同的作用域中变量名是可以相同的,在同一个作用域中,不能重名.在输出某个变量时,遵循就近原则.
4.1.数据类型的作用?
不同数据类型占用的空间大小不同,数据类型的作用是指导JVM在运行程序时给该数据分配多大的内存空间.
4.2java中的数据类型包括两种:
基本数据类型:
包括四大类,八小种:
第一类: 整数型
byte,short,int,long
第二类: 浮点型
float,double
第三类: 布尔型
boolean
第四类: 字符型
char
引用数据类型:
类
接口
数组
[String]
....
4.3字符串("..")不属于基本数据类型.属于引用数据类型
4.4八中数据类型占用的大小为多少?
基本数据类型 占用空间大小[单位:字节]
---------------------------------------
byte 1
short 2
int 4
long 8
float 4
double 8
boolean 1
char 2 字符型
4.4.1计算机只能识别二进制.
4.4.2字节:
1个字节等于8个比特位(例:10010101):
1 byte = 8 bit
一个比特位就是一个二进制位
1KB = 1024byte
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1TB = 1024*1024*1024*1024*8 bit
4.5整数型当中的byte类型,占用1个字节,所以byte类型的数据占用8个比特位,那么byte类型的取值范围是多少?
关于java中的数字类型,数字都是有正负之分的,在二进制中最左边有个"符号位",代表着正负,0代表正数,1代表负数.
byte最大值为01111111 0为符号位.也就是最大值为127.
byte类型的最小值为-128(和反码有关)
byte的范围是127到-128,一共256种不同的情况
4.6八种基本数据类型当中char类型标识的是现实世界中的文字,文字和计算机二进制之间"默认"情况下不存在任何转换关系.为了让计算机可以表示现实世界的文字,需要人们提前制定好文字和二进制之间的对照关系,这种对照关系被称为字符编码.最先出现的是:ASCII码
例如'a'-->01100001
'A'-->65
'0'-->48
'a'转换到-->0110001为解码,01100001-->'a'为编码,解码和编码采用的是同一个对照表.
简体中文的编码方式:
GB2312 < GBK < GB18030 //内从小到大.
繁体中文:bjg5
unicode编码方式:统一了全球所有的方式.
UTF-8
UTF-16
UTF-32
java语言采用unicode编码方式,所以"标识符"可以用中文
现在实际开发中,UTF-8开发项目较多.
byte 1字节 -128-127
short 2字节 -2的15次方到2的15次方(-32768~32767)
int 4字节 -2147483648~2147483647
long 8字节
float 4字节
double 8字节
boolean 1字节 true false
char 2字节 0-2的16次方~1(0-65536)
"成员"变量没有赋值时,系统会默认赋值.局部变量不会
数据类型 默认值
---------------------------------
byte、short、int、long 0
float、double 0.0
boolean false [false也相当于0，true为1]
char \u0000
八种数据类型的默认值都向0看齐
8.1char c = '国';
System.out.println(c);
//输出为国,正好说明一个汉字为两个字节.
8.2.char类型,转义字符 \
char c = '\n';
System.out.println(c);
//若按照以前的知识将,\n为一个字符串,编译会报错,但在java中"\"
具有特殊功能,具有转义的功能,\n代表着一个字符,为"换行符".
\n =>属于char类型的数据.
System.out.println与System.out.print的区别?
System.out.println代表输出并换行,System.out.print代表输出不换行.
\t :制表符,也就是tab键,和空格不同,他们的ASCII不一样
\\ :表示 \,第一个将后面的反斜杠转译为普通的 \字符.
\' :表示一个普通的单引号 '
\" :表示普通的双引号
8.3JDK中自带的native2ascii.exe命令
在命令行输入native2ascii 然后输入中文就可以展示中文的字符码
\u4e2d :16进制,表示"中"
1.Java语言中得"整数型字面值"被默认当作int类型来处理,要让这个"整数型字面值"被当作long类型来处理得话,需要在"整数型字面值"后面添加"L",建议使用大写得L.
2.java语言当中整数型字面值有三种表示方式:
2.1十进制(是一种缺省默认的方式)
2.2八进制(在编写八进制整数型字面值时,需要以0开头)
2.3十六进制(需要以0x开头)
int i = 010; //八进制形式
int ix = 0x123;//十六进制形式
3.自动类型转换:
long i =456;//在java语言中,整数型字面值默认当中int,而i变量设置的是long类型,将int类型赋值给变量i,存在类型转换.int类型转换为long类型,int为小容量,long为大容量,小容量可以自动转换为大容量,称为自动类型转换机制.
3.1 long z = 2147483648;//此时,这个数值已经超过int类型的容量.此时需要将其默认int类型改变:
long z = 2147483648L;//这样默认就当作long类型了.
4.大容量转换为小容量:(强制类型转换!!!!)
long l = 100L;
int x = l; //编译报错,long类型转换为int类型,报错.
若想大容量转换为小容量,就得强制类型转换.
使用强制类型转换符,虽然编译通过,但可能损失精度.(可能损失很严重.所以强制类型转换慎用!!)
int x = (int)l;//强制类型转换.
强制类型转换原理:
例如long数据为100L;
则它的二进制为: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
强制转换为int类型:四个字节:
00000000 00000000 00000000 01100100
把前面的四个字节砍掉.
例:
long y= 2147483647L;
int x = (int)y;
System.out.println(x);输出为:[-2147483648] 负数,损失精度太严重.
5.byte的转换类型:
byte a = 50;//成功,byte比较特殊.
byte c = 127;//成功
byte b1 = 128; //编译错误,需要: byte b1 = (byte)128;
//按刚才的强制类型转换来说,此处任意一个都不能编译通过,但运行后发现,只有b1编译不通过,此处我们可以发现,当整数字面值在byte的取值范围内时,不需要强制类型转换也可以编译成功.
6.short b = 32767;//成功.
short b1 = 32768;//报错//超过short的最大值.
7.char c = 65535;//通过
char c = 65536;//不通过,超过了char的取值范围
总结:byte,short,char在取值范围内,可以直接赋值整数型字面值.不用加强制类型转换.
float 单精度【4个字节】
double 双精度【8个字节,精度较高】
double相对于银行数据来说,精度太低.不适合做财务软件.所以SUN在基础SE类库当中准备了精确度更高的引用数据类型.是java.math.BigDecimal
java提供了一套庞大的类库.java程序员是基于这套基础的类库来开发的,所以要知道java的SE类库的字节码在哪.
要知道javaSE的源码在哪
SE类库字节码: C:\Program Files\Java\jdk1.8.0_152\jre\lib\rt.jar
SE类库源码: C:\Program Files\Java\jdk1.8.0_152\src.zip
10.2所有的浮点型字面值[3.0],默认值被当作double类型来处理,
要想该字面值当作float类型来处理,需要在字面值后面添加F/f
double b = 3.0;
float f = 5.1;//编译错误.5.1是double类型,将其赋值给float类型,报错. 第一种方案:float f = (float)5.1;(强制类型转换)
第二种方案:float f = 5.1f;(没有强制转换)
注意:double和float在计算机当中存储的都是近似值.
因为现实世界有些是无限循环的,例如:3.333...
所以存储无限的数据只能存储近似值.
在java中booleanl类型只有两个值,true和false,没有其它值.
boolean flag = 1;//报错,不兼容.
boolean flag = true;
if(flag){
System.out.println("成功")
}else{
System.out.println("失败")
}
转换规则:
1.八种基本数据类型当中除布尔类型之外,剩下的7种数据类型之间都可以互相转换.
2.小容量向大容量转换.称为自动类型转换.容量从小到大:
byte<short<int<long<float<double
char<
注:
任何浮点类型不管占用多少个字节,都比整数型容量大.
char和short可表示的种类数量相同,但是char可以取更大的正整数.
char c = 97;//成功
3.大容量转换成小容量,一般都得强制类型转换,需要加强制类型转换符,程序才能编译通过,但在运行阶段可能会损失精度.谨慎使用!!
4.当整数型字面值没有超过byte,short,char的取值范围时,可以直接将int类型的字面值赋值给byte,short,char类型的变量
5.byte,short,char在进行混合运算时,各自先转换成int类型,在做运算.
6.多种数据类型混合运算,先转换成容量最大的那种数据类在做运算.
13.1
int f = 10/3;//编译成功,输出为3
13.2
double d = 10/3;//输出为3.0,因为右边的int类型先进行运算,然后再转换为double类型,为3.0
13.3
double dd = 10.0/3;//输出为3.3333333333333335
解释:在执行右边的数据运算时,先将数据都转换为大容量的数据类型,然后再进行运算,所以即为10.0/3.0,结果为3.3333333333333335;
13.4
long g = 10;
int d = g/3;//编译错误,long类型除以int类型,最终会转换为long类型,而long类型不能自动转换为int类型,即使没有超出int类型的范围.
int d = (int)g/3;//成功
13.5 byte b= 3;//成功,因为字面值默认为int类型,而byte,short,char有着SUN公司给的特权,在字面值的赋值时,只要没有超过其取值范围,就可以赋值成功,
13.5.2byte b= 10/3;//成功,这个是两个int类型相除,得到3的int类型,而又因为它是字面值并且没有超过取值范围,所以也可以赋值成功
13.5.3int i =10;
byte b = i/3;//失败,由于i变量为int类型,除以一个int类型为结果也是为int类型,所以它不是字面值.虽然没有超过取值范围,但由于int类型转换为byte类型,大转换小,编译报错.
13.6 short i = 10;
byte b = 15;
short = i+b;//报错,因为在编译期间会进行语法检查,short,byte,char在进行混合运算时,会先将类型全都转换为int,所以在检查时,发现int类型要赋值给short,报错.
13.7 char i = 'a';
int m = i+100;
System.out.prntln(m);//输出多少?
结果为197.,在运算时,先将char转换为int类型,为97,在进行运算,所以m为197.
14.1算术运算符
+、-、*、/、%、++、--
++运算符：可以出现在变量前，也可以出现在变量后。
14.1.1出现在后?
int a = 100;
int b = a ++;
输出a,b
a输出为101，b输出为100,由于是a++,所以先进行赋值运算,然后进行自身的++,所以b为100,a为101.
14.1.2出现在前?
int a = 100;
int b = ++ a;
输出a,b
a输出为101，b输出为101,由于是++a,所以先进行自身的++,然后再进行赋值运算,所以b为100,a为101.
--亦是如此.
14.1.3
int i = 100;
System.out.println(i ++);//输出100
System.out.println(i);//输出101
关系运算符
逻辑运算符
字符串连接运算符
三元运算符
赋值类运算符
>
>=
<
<=
==
!=
注意:=是赋值运算符;
关系运算符的运算结果一定是布尔类型:true/false
逻辑运算符:
& 逻辑与 (两边的算子都是true,结果才是true)
| 逻辑或 (两边的算子只要有一个是true,结果就是true)
! 逻辑非 (取反,!false就是true,!true就是false,这是一个单目运算符)
^ 逻辑异或 (两边的算子只要不一样,结果就是true)
&& 短路与 (两边的算子都是true,)
|| 短路或 (两边的算子都是true,)
1.逻辑运算符要求两边的算子都是"布尔"类型,并且逻辑运算符最终的运算的结果也是一个布尔类型.
2. 短路与和逻辑与最终的运算是相同的,只不过存在短路现象.
3. 短路或和逻辑或最终的运算结果是相同的,只不过短路或存在短路现象.
4.什么情况下发生短路现象?
int i=10,b = 8;
i<b && ++i<b;//短路与
x<y 结果是false,整个表达式结果已经确定为false.
所以后面的表达式就不会再去执行,这种现象被称为短路现象.
短路与才会存在短路现象,逻辑与不会出现短路现象.
5.什么时候选择使用逻辑与运算符?什么时候选择使用短路与运算符?
在不管第一个表达式的真假,第二个表达式一定要执行时,使用逻辑与.
在第一个如果没有就不能执行第二个表达式的话,使用短路与.
6.什么情况下使用短路或?
第一个表达式执行结果为true,会发生短路或,不会执行后面的语句
7.什么情况下使用短路与?
第一个表达式执行结果为假,就会发生短路或,不会执行后面的语句.
17.1赋值运算符
包括两种:
基本的赋值运算符: =
扩展的赋值运算符:+=、-=、*=、/=、%=
赋值类的运算符优先级：先执行等号右边的表达式，降级过赋值给左边的变量。
byte b = 10;
b = b+5;//编译报错
b += 5;//编译成功.
思考:b = b+5与b += 5相等嘛?
不相等.b += 5同b = (byte)(b+5);相同.
int i = 10;
i += 5;等同于i = (byte)(i+5);
结论:扩展类运算符不会改变最终运算数据类型.假设最初为byte类型,无论怎么加其他类型.最后结果还是最初的byte类型.
//能否编译通过?
17.2字符串连接运算符
17.3三目运算符/三元运算符
1.当"+"运算符只要两边的数据有一个是字符串的话,一定会进行字符串拼接.
2.例如你定义两个变量，a,b,输出为a+b=(a+b)的形式，你需要进行字符串拼接：
System.out.println(a+"+"+b+"="+(a+b));
这样进行输出，就可以进行字符串的拼接。
3.引用数据类型:
String,SUN公司在javaSE当中提供的字符类型.
String s = "abc";
语法:
布尔表达式?表达式1:表达式2;
当布尔表达式的结果为true时,选择表达式1作为整个表达式的执行结果.
当布尔表达式的结果是false时,选择表达式2作为整个表达式的执行结果.
boolean sex = false;
String i = sex ? "男": "女";
注意:
char c1 = sex ? "男":'女'; //编译错误,语法错误,sex值不确定,后面是string类型和字符类型,不能赋值给字符型类型.
选择结构:
20.1.1if if...else
if语句的特点,只要一个分支执行,整个if语句全部结束
所有的控制语句都是可以嵌套的.[代码格式尽应该完美]
设置分数等级[0-100],0-60为E,60-70为D....
然后分数输出指定的内容.
double score = 60.0;
String gra;
int flag = 0;//设置一个旗帜
if(score < 0 || score >100){
gra = "不合法";
flag = 1;
}else if(score >= 90){
gra = "等级为A类";
}else if(score >= 80){
gra = "等级为B类";
}else if(score >= 70){
gra = "等级为C类";
}else if(score >= 60){
gra = "等级为D类";
}else{
gra = "等级为E类,考试不合格";
}
String grade = "该考生的成绩"+gra+(flag==1?"":"等级");
System.out.println(grade);
20.1.2
收集用户输入的数据:
//第一步,创建键盘扫描器对象
java.util.Scanner s = new java.util.Scanner(System.in);
//第二部,调用Scanner对象的next()方法,开始接收键盘的用户输入.
1.// String str = s.next();//若像接收string类型的数据,则使用next();
2.//double score = s.nextDouble();//接收double数据类型的数据;
3.//int i = s.nextInt();//接收int类型的数据.
总:将成绩等级和用户输入整合到一块.
//收集用户输入数据
java.util.Scanner s = new java.util.Scanner(System.in);
double score = s.nextDouble();//确定键按下,将score赋值.
System.out.println("您的分数为:"+score);
String gra;//设置提示的等级
int flag = 0;//设置一个旗帜,标志是否进入第一个if
if(score < 0 || score >100){
gra = "不合法";
flag = 1;
}else if(score >= 90){
gra = "等级为A类";
}else if(score >= 80){
gra = "等级为B类";
}else if(score >= 70){
gra = "等级为C类";
}else if(score >= 60){
gra = "等级为D类";
}else{
gra = "等级为E类,考试不合格";
}
String grade = "该考生的成绩"+gra+(flag==1?"":"等级");
System.out.println(grade);
20.1.4
if(false)
System.out.println("男");
System.out.println("呵呵");
//此时,条件为假并且没用大括号,系统默认将if下的第一句包括在大括号内:
if(false){
System.out.println("男");}
//然后第二句在外面,不在之内.
System.out.println("呵呵");
总:输出的是"呵呵";
20.1.5
if(false)
System.out.println("男");
System.out.println("呵呵");
else
System.out.println("女");
//报错,提示else没用if;
switch
switch语句也属于选择结构,也是分支语句
switch语句的语法结构:
完整的switch语句:
switch(int或string类型的字面值或变量){
case int或string类型的字面量或变量:
java语句;
...
break;
case int或string类型的字面量或变量:
java语句;
...
break;
default :
java语句;
....
}
//switch后面和case后面只能跟int类型或者string类型的数据，不能是其它类型的数据，当然byte，short，char也可以写在switch和case后面，因为可以进行自动类型转换。可以转换成int类型。
switch中写的int或string将与case进行比较，若相同则执行case后面的java语句，并且break退出switch，若没加break,则继续执行后面的case语句.
2.如果没有加break,会存在case穿透现象:
switch(i){
case 1:
System.out.println("星期一");
case 2:
System.out.println("星期2");
case 3:
System.out.println("星期3");
case 4:
System.out.println("星期4");
default :
System.out.println("不合法");
}//在你i的值为2时,匹配到第二个,由于2没有写break匹配到结果后终止,所以继续向后输出,直到遇见break或者结束.
例:
i为3,输出为:
星期3
星期4
不合法
这就是case穿透.带来的问题.
循环结构:
1.for
1.1for循环的语法:
for(初始化表达式;布尔表达式;更新表达式){
//是需要重复执行的代码片段[循环体]
}
1.2 for循环的执行过程/执行原理?
1.2.1初始化表达式、布尔表达式、更新表达式都不是必须的！【但是两个分号是必须的】
1.2.2初始化表达式最先执行，并且在整个for循环中只执行一次。
1.2.3布尔表达式必须是true或者false，不能是其他值
1.2.4for的执行过程：
* 先执行初始化表达式，并且该表达式只执行一次
* 判断布尔表达式的结果是真还是假：
* 布尔表达式为true：
* 执行循环体
* 执行更新表达式
* 判断布尔表达式是真是假：
* true：
* 执行循环体
* 执行更新表达式
* 判断布尔表达式是真还是假？
....
* false
* 循环结束
* 布尔表达式为false：
* 循环结束
九九乘法表的写法：（
for(int i = 1;i < 10;i ++){
for(int j = 1;j <= i;j ++){
System.out.print(j+"*"+i+"="+i*j+" ");//要留出一个空格,以便于在一行中,将其分开
}
System.out.print("\n");
// System.out.println();//这种也可以,就是在输出最后加上换行符
}
//要求:1-100之间的质数，每八个质数换一行;
int nchange = 0;//是否需要换行旗帜
for(int i = 2;i<=100;i++){
int flag = 0;
int intI = (int)(Math.sqrt(i));//求其一个数的开方.
//在你一个数从1开始求余，求余到你开根号的整数时，若
//还没有余数为0的,即这个数就是质数/素数! 简单举例子来说,一个16,从1开始取余,若你在4(包括)之前还米有取到能整除的数,那么
//后面的数将不可能再被整除尽,因为你大于开方后,若出现能整除的,例如8,那16/8=2,所以这个得数2就一定在你之前就已经除过,
//所以你不可能到8.因为8可以整除,那在2的时候就也能整除了,前后反证,所以除数的大小范围,到开方即可.(开方时,你除数与得数都相等)
//即取到了所有的情况!
for(int j = 1;j <= intI;j++){
if(j != 1 && i % j == 0){
}else{
flag++;
if(flag == intI ){
System.out.print(i+" ");
nchange++;
if(nchange==8){
System.out.println();
nchange = 0;//重置是否换行旗帜
}
}
}
}
}
while
1.while循环的语法结构：
while(布尔表达式){
循环体:
}
2.执行原理:
* 先判断布尔表达式的结果.
true:
* 执行循环体
* 判断布尔表达式结果
false:
* 循环结束
3.循环次数
0-N次
死循环时,后面的语句不能被执行.例:
int i = 10,j = 5;
while(i>j){//在编译器无法确定shitrue还是fasle,所以这种在编译期间不报错.
//while(true){//这种情况就会在编译期间报错报错.
System.out.println("--");
}
System.out.println("外");//这里执行不了.无法访问语句
do...while()
1.do..while的语法结构:
do{
循环体;
}while(布尔表达式);
2.执行原理:先执行循环体,判断布尔表达式,为真则继续执行循环体,为假结束循环.依次执行.
3.do..while循环执行次数是1-N次,
4.do...while循环语句最终有一个;分号,别忘了!!
控制循环的语句
break
语法:
break;
可以用在switch和循环语句当中,
2.break中止哪个循环呢?
默认请款下,break中断的是离他最近的循环,不会影响到外层循环,如果想影响外层循环,需要给for循环起名字.然后break 循环名字;
for1:for(){
for2:for(){
break for1;
}
}
continue
continue:表示下一个:
continue表示直接进入下一个循环继续.
break与continue的区别?
break直接全部结束最近的循环.
continue是结束本次循环语句,继续跳到下一次循环.
方法的基础语法:
如果有好几段代码几乎相同,就是一些参数不同,就可以写在方法里,代码复用.减少了代码重复程度,提高的效率.
方法的本质就是代码片段,可以完成某个特定的功能,并且可以重复使用.
方法对应的单词为: Method
方法在C中叫做: 函数/Function
方法定义在类体当中,一个类可以定义多个方法.编写的位置没有先后顺序,可以随意.
只要带有return关键字的语句执行后,方法结束!不再执行这个方法.
** 方法体中不能再定义方法!!
方法名使用小驼峰命名法.
2.方法的重载:onload
1.正确性
2.可读性
3.健壮性
4.高效率与低存储:时间复杂度* 空间复杂度(衡量一个算法的标准)
不要在工作空间时点击默认这个工作空间.
搜索package,navicate.console等拉到左边的栏中.
23.1如何导入已有的工程?
file点击import,然后点击导入已有的工程,然后找目录找到哪个工程,
找到之后会发现,提示工作空间中已有这个工程,这是因为重名的原因,需要在eclipse中将其现有的工程文件改一下名字,就可以.单单去我的电脑改文件夹名字是不行的.
23.2将其设置的默认工作空间再取消掉的操作:
在windows下有一个preferences,然后点击General下点击Strat Up and Shutdown就可以实现.
23.3怎么导入一个写的java文件?
直接复制,然后粘贴到你想要转到哪个包下的粘贴即可.
23.4如何删除一个工程?
有一个选项,是否从硬盘上删除?,勾上的话,文件在计算机就没有了.
也可以右键选择close工程.然后下三角有一个filter,不显示close工程
24.1数组本身是引用数据类型.而数组中的元素是任意数据类型.
24.2创建数组对象会在内存中开辟一整块连续的空间,而数组名中引用的是这块连续空间的地址.
24.3数组的长度一旦确定,就不能再修改.
24.4数组的分类:
按照维度: 一维数组,二维数组....
按照数组元素类型:基本数据类型元素数组,引用数据类型y
24.5一维数组的声明和初始化。
int[] ids =new int[]{1,2,3,4};//静态,值直接附上
String[] names =new String[5];//动态,指定长度,值不确定
总结:一旦初始化完成以后,数组的长度就确定了.
24.5.2怎么调用数组指定位置的元素.
names[0] = "zhangsan";
names[1] = "lisi";
24.5.3数组元素的默认初始化值
int[] arr =new int[5];
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);//输出为5个0;
}
整型元素的默认初始化值都为0;
浮点型元素的默认初始化值为0.0;
char类型元素的默认初始化值为:'\u0000';
boolean类型元素的默认初始化值为:false
引用数据类型的初始化默认值为:null
1.静态:
int[][] arr = new int[][]{{1,2,3},{5,6},{7,8,9}};
2.动态指定:
String[][] str = new String[3][2];
代表着一维数组为3个元素,然后这每个元素都是长度为2的元素.
3.也可以将中括号放在变量的后面:
int arr[][] = ...
int[] arr[] = ...
这两个都是二维数组
也可以简写形式:
int[] arr = {1,2,3};//可以
但先声明再赋值,就不能简写:
int[] ids;//声明变量
ids = new int[]{1,2,3,5};//这个不能省略new
如何遍历二维数组:
int[][] arr = new int[][]{{1,2,3},{5,6,4},{7,8,9}};
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
System.out.println(arr[i][j]);
}
}
int[][] arr = new int[4][3];//这就代表外面得数组为4个长度,并且这四个都各自指向了一个数组堆的地址.
System.out.println(arr[0]);//输出的是一个十六进制地址
[I@1540e19d :[代表为一维数组,@后面为地址对象
:: double[][] arr2 = new double[4][];
System.out.println(arr2[0]);//null.因为指定其内部元素为数组类型,为引用数据类型,所以不指定值时是null默认值.
System.out.println(arr2[0][0]);//报错=>null[0]就会报错.
4.不同类型的一维数组元素的默认初始化值各是多少?
整型:0
浮点型:0.0
char:0(ASCII值为0)
boolean:false
引用数据类型:null
1.数据与数据之间的逻辑关系:集合,一对一,一对多,多对多
2.数据的存储结构:
2.1线性表:顺序表(例:数组),链表,栈,队列.
2.2树形结构:二叉树
2.3图形结构:
26.2算法:
排序算法:
搜索算法:
1.如何理解二维数组?
数组属于引用数据类型.
数组的元素也可以是应用数据类型.
一个一维数组A的元素如果还是一个一维数组类型的,则称A称为二维数组.
2.1String[][] str2 = new String[3][];
2.2String[][] str2 = new String[3][2];
//第二个中括号指定一个固定长度与不指定一个固定长度的区别:
//指定一个长度,代表会在内存空间开辟一个数组的空间,然后将地址值存入一维数组对应里,这样,你去访问时,它返回的就是一个地址值(没有赋值)
//没有指定长度,则只能说明你的一维数组中的元素是数组,但没有在内存中开辟空间,所以此时访问,为null.
声明: int[] x,y[];在声明之后赋值,以下选项允许通过编译的是:
A x[0] = y;
B y[0] = x; //成功
C y[0][0] = x;
D x[0][0] = y;
E y[0][0] = x[0]; //成功
F x = y;
1.数组元素的赋值(杨辉三角,回形数等)
1.1杨辉三角:从第三行开始,除了第一个和最后一个,每个都是上一个和上一个的前一个之和
int[][] arr = new int[10][];
for (int i = 0; i < arr.length; i++) {
arr[i] = new int[i + 1];//将其arr的一维数组的i元素的长度计算出来。
arr[i][0] = arr[i][i] = 1;
for (int j = 1; j < arr[i].length - 1; j++) {
arr[i][j] = (arr[i - 1][j - 1]) + (arr[i - 1][j]);
}
}
输出:
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1.2回形数:给定一个数值,然后自左向右输出这个数值的行,再向下接着输出相同的行,然后再向左输出,沦为一圈.
int num = scanner.nextInt();
int minX = 0;//开始的x坐标为0,
int maxX = num-1;//最大x坐标为length-1
int minY = 0;
int maxY = num-1;
int count = 0;
int[][] arr = new int[num][num];//行和列确定,为输入的num行,num列
while (minX<=maxX){
for (int i=minY;i<=maxY;i++){
arr[minX][i] = ++count;
}
minX++;
for (int i=minX;i<=maxX;i++){
arr[i][maxY] = ++count;
}
maxY--;
for (int i=maxY;i>=minY;i--){
arr[maxX][i] = ++count;
}
maxX--;
for (int i=maxX;i>=minX;i--){
arr[i][minY] = ++count;
}
minY++;
}//遵循的算法思想是,执行一列,就将这一列的最大值减去1或最小值加1,直到最大与最小相违背结束.
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
2.求数值型数组中元素的最大值,最小值,平均数,总和等.
3.数组的复制,反转,查找(线性查找,二分法查找等)
二分查找:砍半查找
int[] arr = new int[]{-56,-34,0,34,35,56,78,99,120};
int start = 0;//起始位置索引
int end = arr.length-1;//起始末尾位置索引
Scanner scanner = new Scanner(System.in);
System.out.print("请输入数字:");
int num = scanner.nextInt();//用户输入的数字
boolean flag = true;//是否找到
while (start<end){
int middle = (start+end)/2;//取其左中间值索引
if(num == arr[middle]){
flag = false;
System.out.println("找到了数,位置为:"+middle);
break;
}else if(num > arr[middle]){
start = middle+1;
}else {
end = middle-1;
}
}
if(flag){
System.out.println("没有找到!!");
}
4.数组元素的排序算法.
常见的排序算法:
选择排序:
直接选择排序,堆排序
交换排序
冒泡排序O(n^2),快速排序O(nlgn)
插入排序
直接插入排序,折半插入排序,Shell排序
归并排序
桶式排序
基数排序
冒泡排序实现例子:
for (int i = 0; i < arr.length - 1; i++) {//每次都第一个开始与自己后面的进行比较,若后面的比自己小,则交换.
for (int j = 0; j < arr.length - 1 - i; j++) {//由于每次都比较出最大的一个,所以每次比较就减一次数比较
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
衡量排序算法的优劣:
时间复杂度**,空间复杂度,稳定性
定义在java.util包下.
提供了很多操作数组的方法
1.boolean equals(int[]a,int[] b) 判断两个数组是否相等
2.String toString(int[] a) 输出数组信息
3. void fill(int[] a,int val) 将指定值填充到数组之中,将新值替换旧值
4.void sort(int[] a) 对数组进行排序
5.int binarySearch(int[] a,int value) 对排序后的数组进行二分法检索指定的值
1. ArrayIndexOutOfBoundsException: 数组角标越界异常. 合理范围: [ 0 - length- 1 ] , 其它的都是越界
2. NullPointerException: 空指针异常
2.1 int[ ] arr = null ;
arr[ 0 ] ;
2.2 int [ ] [ ] arr = new int [ 4 ] [ ] ;
arr[ 0 ] [ 0 ] ;
一旦程序出现异常, 未处理则, 终止运行.
1.三条主线:
Java类及类的成员:属性,方法,构造器;代码块,内部类
面向对象的三大特征:封装性,继承性,多态性,(抽象性)
其它关键字:this,super,static,final,abstract,interface,package,import
1.类:对于某个事物抽象概念,是抽象的,概念上的定义
2.对象:相当于该事物的实例,是实际存在的该类事物的每个个体.
3.面向对象程序设计的重点是类的设计.
设计类,就是设计类的成员.
设计类:
就是设计类的成员.
属性:
行为(方法):
4.类中属性的使用:
属性(成员变量) vs 局部变量
1.相同点:
定义变量的格式: 数据类型 变量名= 变量值.
先声明,后赋值
变量都有对应的作用域.
2.不同点:
属性:直接定义在类的一对{}内,
局部变量:声明在方法内,方法形参,代码块内,构造器形参,构造器内部的变量.
2.2关于权限修饰符的不同:
属性:可以在声明属性时,指明其权限,使用权限修饰符.常用的:(private,public,缺省的,protected)
局部变量:不可以使用权限修饰符.
2.3默认初始化值的情况：
属性：类的属性，根据其类型，都有默认初始化值。
整型(byte,short,int,long):0
浮点型(float,double):0.0
字符型(char):0或'\u0000'
布尔型(boolean):false
应用数据类型(类,数组,接口,String):null
局部变量:没有初始化值,在调用之前,一定要初始化赋值.
形参在调用时,赋值即可.
2.4在内存中加载的位置:
属性:加载在对空间中(非static)
局部变量:加载到栈空间中
2.5方法得定义：
1.方法的声明：权限修饰符 放回值类型 方法名([形参列表]) {
方法体(java语法)
}
1.1权限修饰符:
Java规定的private,public,缺省,protected -->封装性再讲.
1.2返回值类型:
有返回值:必须在声明时指定返回值得类型.同时在方法中使用return关键字来返回指定类型的变量和常量.
无返回值:用void表示,方法中就不需要使用return了,如果使用,只能"return;"来表示.return后不可再写其它的语句
2.我们定义方法的时候,该不该写返回值?
题目要求:
凭经验:具体问题具体分析
1.2方法名:属于标识符,符合标识符的规范.
1.3形参列表：方法可以声明0个，1个，或多个形参
数据类型 形参...
1.4return关键字的作用：结束方法的作用;② 返回所要的数据的作用,③return关键字后面不能再有语句.
1.6在方法中,可以调用类中的属性或方法.
1.7方法中不可以定义方法.
package com.zqk.day02;
/**
* ClassName:StudentTest
* PacKage:com.zqk.day02
* Description: 进行学生类的编写
* @Date:2022/4/8 11:28
* @Athor:zqkyy email:zqkqk@qq.com
*/
public class StudentTest {
public static void main(String[] args) {
Student[] stus = new Student[20];
StudentTest sc = new StudentTest();
sc.setValue(stus);//调用赋值方法
System.out.println("输出学生信息************");
sc.print(stus);//输出学生信息
System.out.println("输出为************\n");
sc.searchState(stus, 3);//输出年级为3的信息
System.out.println("排序输出************");
sc.sortScore(stus, sc);//快速排序并输出
}
/**
* 给元素赋值
*
* @param stus
*/
public void setValue(Student[] stus) {
for (int i = 0; i < 20; i++) {
//给数组元素赋值，给Student这个对象赋值
stus[i] = new Student();
stus[i].number = (i + 1);
stus[i].state = (int) ((Math.random() * 5) + 1);
//成绩：[0-100]
stus[i].score = (int) (Math.random() * 99);
}
}
/**
* 遍历数组的方法
*
* @param stus
*/
public void print(Student[] stus) {
for (int i = 0; i < stus.length; i++) {
System.out.println(stus[i].info());
}
}
/**
* 查找年纪为3的学生信息
*
* @param stus
* @param state
*/
public void searchState(Student[] stus, int state) {
for (int i = 0; i < stus.length; i++) {
if (stus[i].state == state) {
System.out.println(stus[i].info() + ",年级为" + state + "=>");
}
}
}
/**
* 进行冒泡排序并遍历
*
* @param stus
*/
public void sortScore(Student[] stus, StudentTest sc) {
for (int i = 0; i < stus.length - 1; i++) {
for (int j = 0; j < stus.length - 1 - i; j++) {
if (stus[j].score > stus[j + 1].score) {
Student temp = stus[j + 1];
stus[j + 1] = stus[j];
stus[j] = temp;
}
}
}
sc.print(stus);//输出学生信息
}
}
//定义一个学生类
class Student {
int number;//学号
int state;//年级
int score;//成绩
public String info() { //info方法,发挥学生的具体信息
return "学号:" + number + ",班级:" + state + ",成绩:" + score;
}
}
4.1 面向对象思想编程内容的三条主线分别是什么?
① 类及类的成员: 属性, 方法, 构造器; 代码块, 内部类
② 面向对象的三大特征: 封装, 继承, 多态
③ 其它关键字: this , super , abstract , interface , final , package . . .
③ 面向对象的编程思想?
( 类和对象的概念, 面向对象的三大特征, 接口. . . . )
4.2 谈谈你对面向对象中类和对象的理解, 并指出二者的关系?
类: 对事物的描述, 抽象的, 概念上的内容.
对象: 实实在在存在的一个个体.
对象是由类new 出来或派生出来的.
4.3 类和对象的创建和执行操作有哪三步？
① 创建类
② 类的实例化
③ 通过调用对象的结构：对象. ( 属性/ 方法)
4.4 类的方法内是否可以定义变量, 是否可以调用属性? 是否可以定义方法? 是否可以调用方法?
可以定义变量, 可以调用属性, 不可以定义方法, 可以调用方法.
<< JVM规范>>
在java语言范畴中,我们将功能结构等封装到类中,通过类的实例化,来调用具体的功能结构.
2.Java语言与前端和数据库交互时,都体现为类,对象.
class Phone{
public void showInfo(Car car){
car.show();
}
}
class Car{
public void show(){
sysout("__");
}
}
public static void main(String[] args){
new Phone().showInfo(new Car());//匿名对象的使用.
}
1. ArraysUtil类:
package com. zqk. day04 ;
import sun. security. util. Length ;
public class ArraysUtil {
public int searchMax ( int [ ] arr) {
int max = arr[ 0 ] ;
for ( int i = 0 ; i < arr. length; i++ ) {
if ( arr[ i] > max) {
max = arr[ i] ;
}
}
return max;
}
public int searchMin ( int [ ] arr) {
int min = arr[ 0 ] ;
for ( int i = 0 ; i < arr. length; i++ ) {
if ( arr[ i] < min) {
min = arr[ i] ;
}
}
return min;
}
public int searchIndex ( int [ ] arr, int item) {
for ( int i = 0 ; i < arr. length; i++ ) {
if ( item == arr[ i] ) {
return i;
}
}
return - arr. length;
}
public void sort ( int [ ] arr) {
for ( int i = 0 ; i < arr. length - 1 ; i++ ) {
for ( int j = 0 ; j < arr. length - 1 - i; j++ ) {
if ( arr[ j] > arr[ j + 1 ] ) {
int temp = arr[ j] ;
arr[ j] = arr[ j + 1 ] ;
arr[ j + 1 ] = temp;
}
}
}
}
public void print ( int [ ] arr) {
for ( int i = 0 ; i < arr. length; i++ ) {
System . out. print ( arr[ i] + " " ) ;
}
}
}
2. 测试:
package com. zqk. day04 ;
public class ArraysUtilTest {
public static void main ( String [ ] args) {
ArraysUtil au1 = new ArraysUtil ( ) ;
int [ ] arr = new int [ ] { 1 , 6 , - 20 , 0 , - 25 , 78 , 4 , 15 , 99 , - 32 } ;
int index = au1. searchIndex ( arr, - 5 ) ;
if ( index > 0 ) {
System . out. println ( "找到了，索引为：" + index) ;
} else {
System . out. println ( "没到找：" + index) ;
}
输出:
没到找：- 10 ;
System . out. println ( "排序前" ) ;
au1. print ( arr) ;
System . out. println ( "排序后" ) ;
au1. sort ( arr) ;
au1. print ( arr) ;
输出:
排序前
1 6 - 20 0 - 25 78 4 15 99 - 32
排序后
- 32 - 25 - 20 0 1 4 6 15 78 99
}
}
定义:在同一个类当中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可.
两同一不同:
同一个类,相同方法名
参数列表不同:
参数个数不同:
参数类型不同:
public void getSum(int i,String s){...}
public void getSum(String s,int i){...}
public void getSum(double b,int i){...}
判断是否是重载:
跟方法的权限修饰符,返回值类型,和形参的名字都没有关系.
4.在通过对象.方法名时,如何确定一个指定的方法,
① 方法名
② 参数列表
格式: 数据类型 ... 形参名
public void show(String ... strs){}
//调用
show();
show("zqk");
show("zqk","ymm");
//可变形参必须放在最后
2.public void getSum(int i,String ... str){}
1. 基本数据类型传递后是赋值. 然后在你调用之后就与其没关系了.
例:
public void changeItem ( int i, int j) {
int temp = i;
i = j;
j = temp;
}
在main方法中进行调用转换值:
int i= 10 , j= 20 ;
Test t1 = new Test ( ) ;
t1. changeItem ( i, j) ;
sysout ( i, j) ;
2. 引用数据类型传递后就会改变其值, 因为你传递的是地址, 操作的是同一个内存地址的空间.
例:
public void changeItem ( int [ ] t) {
t[ 0 ] = t[ 1 ] ;
}
在main方法中进行调用转换值:
int [ ] t = new int [ ] { 1 , 2 }
Test t1 = new Test ( ) ;
t1. changeItem ( int [ t) ;
sysout ( t) ;
例:
class Data {
int m;
int n;
}
Data d1 = new Data ( ) ;
d1. m= 10 , d1. n= 20 ;
public void changeMn ( Data data) {
int temp = data. m;
data. m = data. n;
data. n = data. m;
}
changeMn ( d1) ;
sysout ( "m为:" + d1. m+ "-n为:" + d1. n) ;
1.public class Test{
psvm(){
int a=10,b = 20;
method(a,b);//编写method方法,使其下方输出为a = 100,b = 200.
sysout("a = "+a+",b = "+b);
}
}
2.定义一个int类型的数组,:int[] arr = new int[]{12,3.3.34.56.77.432};
让数组的每个位置上的值去除以首位置上的元素,得到的结果,作为该位置上的新值,遍历新数组输出.
3.int[] arr = new int[]{1,2,3};
char[] char1 = new char[]{'a','b'.'c'};
sysout(arr);//输出什么?
sysout(char1);//输出什么?
1.什么是递归?
第一方法体内调用它自身.
递归一定要想着已知的di
例:计算1-100之间的数(例输入的10,则输出为1+2+3+...+10)的之和.
public int sum(int n){
if(n ==1){
return 1;
}else{
return n+sum(n-1);//当你输入的不是1时,它会一直调用sum直到n到1为止,使其都相加.
}
}
2.例二：已知一个数列：f(0) = 1;f(1)=4;f(n+2)=2f(n+1)+f(n);
其中n是大于0的整数,求f(10)的值.
例三:斐波那契数列
例四:汉诺塔问题
例五:快排
13.1 什么是方法重载?
"两同一不同" : 同一个类, 相同方法名: 参数列表不同.
如何调用确定的方法: 方法名-> 参数列表.
13.2 说明Java 方法中的参数传递机制的具体体现?
基本数据类型: 数据值
引用数据类型: 地址值( 含变量的数据类型)
13.3 谈谈return 关键字的使用?
13.3 .1 . 结束方法, 针对有返回值的情况, 返回数据.
13.3 .2 . 结束循环
13.4 提供以下代码的内存解析:
public class TransimitValue {
public static void main ( String [ ] args) {
TransimitValue test = new TransimitValue ( ) ;
test. first ( ) ;
}
public void first ( ) {
int i= 5 ;
Value v = new Value ( ) ;
v. i = 25 ;
second ( v, i) ;
System . out. println ( v. i) ;
}
public void second ( Value v, int i) {
i = 0 ;
v. i = 20 ;
Value val = new Value ( ) ;
v = val;
System . out. print ( v. i+ " " + i+ " " ) ;
}
}
class Value {
int i = 15 ;
}
1. 内存结构: 栈( 局部变量) , 堆( , new 出来的结构对象( 成员变量) , 数组)
2. 变量: 成员变量vs局部变量( 方法你, 方法形参, 构造器内, 构造器形参, 代码块内)
面试: 方法的重载与重写的区别？
throws \ throw
String \ StringBuffer \ StringBuilder
Collection \ Collections
final \ finally \ finalize
抽象类 \ 接口
sleep ( ) \ wait ( )
* * * 可变形参的格式:
( String . . . strs)
注意: 可变形参只能放在最后:
( String str, String . . . strs) ;
( String . . . strs, String str) ;
面向对象的特征之一:封装与隐藏.
例如:
现在我们需要你个Animal的类,里面设有name,age,legs等属性,还有showFeild方法,是输出这个类的基本属性的.2.我们在实例化这个类时,通过调用legs属性给其赋值.(其中legs代表的是动物的腿的个数),但由于现实世界中腿的个数不可能为0或者为负数,所以用户可能给其赋值其负数,为了避免这个问题,我们可以再设一个方法,专门给其legs赋值,在此之前进行判断调用的这个方法的参数是否大于0;3.赋值以后可以实现我们的目标,但是还可以调用之前的legs进行赋值,为了避免这个问题,我们需要将legs不向外暴露,即需要添加private修饰,所以在这就体现了封装性.
class Animal{ //定义一个类
String name;
int age;
private int legs; //私有属性legs
public void setLegs(int priLegs){ //赋值legs方法
if(priLegs > 0){
legs = priLegs;
}else{
legs = 0;
}
}
public void showFeild(){//输出方法
System.out.println(name+age+legs);
}
}
//在主函数中:
public class Test{
public static void main(String[] args){
Animal a1 = new Animal();//实例化Animal类
a1.setLegs(-1); //最终legs会为0
a1.setLegs(4);//赋值成功.
a1.showFeild();//输出结果,
}
}
14.2 我们将类的属性私有化，同时，需要提供一个公共的(public)方法类获取(getXxx)和设置(setXxx)
public int getLegs(){
return legs;
}
14.3 封装性的体现: 不对外暴露的私有的方法 / 单例模式
14.4封装性的体现需要用权限修饰符来配合.
14.14.1 Java规定的四种权限:(从小到大排列:private、缺省、protected、public)
修饰符 类内部 同一个包 不同包的子类 同一个工程 private Yes (缺省) Yes Yes protected Yes Yes Yes public Yes Yes Yes Yes
14.4.2这四种权限可以用来修饰类以类的内部结构:属性、方法、构造器、内部类
具体的:4种都可以用来修饰类的内部结构
修饰类的话,只能使用缺省和public
总结封装性:Java提供了四种权限修饰,来修饰类及类的内部结构,体现了其可见性的大小.
封装性的简单点来说,就是把该隐藏的隐藏起来,该暴露的暴露起来,这就是封装性的设计思想.
构造器(构造方法) constructor
1.构造器的作用:用来创建对象(new + 构造器).
如果没有现实定义类的构造器的话,系统默认提供一个空参的构造器
2.定义构造器: 权限修饰符 类名(构造器名)(形参列表){}
3.构造器的作用:
1.创建对象
2.初始化对象的信息
3.一个类中定义的多个构造器,彼此构成重载.
4.一旦显示的定义了类的构造器之后,系统就不会再提供空参构造器.
5.一个类中,至少会有一个构造器.
1.类是公共的,
2.有一个无参的公共的构造器
3.有属性,且有对应的get,set方法.
public class Test{
private String name;
public Test(){ //构造器
}
public String getName(){
return name;
}
public void setName(String n){
name = n;
}
}
this理解为当前对象.
this可以修饰:属性,方法,构造器
在类的方法中,可以使用this.属性或this.方法的方式.
比如Person p1 = new Person();
① 则在类中使用的this就代表p1
② 使用this.变量,的方式,表明此变量是属性,而非形参
③ 如果你使用this来调用构造器的话,使用this(与构造器形参列表相同);的形式来调用构造器,(在构造器里不能调用自己,否则一直调用自己,出不去了.)25
④ 构造器中不能通过"this(形参列表)"来调自己.
⑤ 如果一个类中有n个构造器,则最多有n-1个构造器使用this
⑥ 规定:"this(形参列表)"必须声明在当前构造器的首行.
⑦ 构造器内部:最多声明一个"this(形参列表)"用来调用其它的构造器.
public class CanGetRiver {
public static void main ( String [ ] args) {
int priDis = 0 , jumpStage = 0 ;
int [ ] stones = new int [ ] { 0 , 1 , 3 , 5 , 8 , 12 , 17 , 58 } ;
boolean isJump = jump ( stones, priDis, jumpStage) ;
System . out. println ( isJump) ;
}
public static boolean jump ( int [ ] stones, int priDis, int jumpStage) {
int n = stones. length;
boolean [ ] [ ] bp = new boolean [ n] [ n] ;
bp[ priDis] [ jumpStage] = true ;
for ( int i = 1 ; i < n; i++ ) {
int j = i - 1 ;
int k = stones[ i] - stones[ j] ;
if ( k > j + 1 ) {
break ;
}
if ( k + 1 <= n - 1 ) {
bp[ i] [ k] = bp[ j] [ k - 1 ] || bp[ j] [ k] || bp[ j] [ k + 1 ] ;
}
if ( i == n - 1 ) {
return bp[ i] [ k] ;
}
}
return false ;
}
}
Boy :
public class Boy {
private String name;
private int age;
public Boy ( String name, int age) {
this . name = name;
this . age = age;
}
public void setName ( String name) {
this . name = name;
}
public void setAge ( int age) {
this . age = age;
}
public String getName ( ) {
return name;
}
public int getAge ( ) {
return age;
}
public void Marry ( Girl girl) {
String bigAge;
bigAge = ( this . getAge ( ) - girl. getAge ( ) >= 0 ? "我的年龄大,我以后会照顾老婆的" : "老婆的年龄大,以后老婆给做饭饭" ) ;
System . out. println ( "我想娶的女人是" + girl. getName ( ) + "," + bigAge) ;
}
}
Girl :
public class Girl {
private String name;
private int age;
public Girl ( String name, int age) {
this . name = name;
this . age = age;
}
public void setName ( String name) {
this . name = name;
}
public void setAge ( int age) {
this . age = age;
}
public String getName ( ) {
return name;
}
public int getAge ( ) {
return age;
}
public void Marry ( Boy boy) {
String bigAge;
bigAge = ( ( this . age - boy. getAge ( ) ) >= 0 ? "老婆的年龄大,以后老婆照顾老公" : "老公的年龄大,以后给老婆做饭饭" ) ;
System . out. println ( "我想嫁给：" + boy. getName ( ) + "," + bigAge) ;
boy. Marry( this ) ;
}
public int compare ( Girl girl) {
return this . getAge ( ) - girl. getAge ( ) ;
}
}
Test :
public class Test {
public static void main ( String [ ] args) {
Boy boy = new Boy ( "张乾康" , 20 ) ;
Girl girl = new Girl ( "袁梦梦" , 21 ) ;
girl. Marry( boy) ;
}
}
1.package的使用:
为了项目中类的管理,提供包的概念
1.2根据类的功能,分为不同的包
1.3使用package声明类或接口所在的包,声明在文件的首行
1.4包,标识符,遵守命名规范,"见名之意"
1.5每点一次,代表一层文件目录
1.6不同的包下可以命名同名的接口,类
2.import关键字的引用
2.1 作用:
在源文件中显示使用import结构引入指定包下的类,接口.
声明在包的声明和类的声明之间
如果需要导入多个结构,则并排导入即可
xxx.*的方式引入包下的所有结构
如果是使用的java.lang包下定义的,则可以省略import结构
如果使用的类是本包下的,则不需要使用import
如果在源文件中,使用了不同包下的同名的类,则必须至少有一个类需要以全类名的方式显示
例如
com.zqk.day05.Account() a1 =...;
如果使用一个包下的子包下的结构,则仍需要导入.
import static;导入xx下的静态结构;属性/fa
model-view-controller
1.构造器的作用是什么?使用时有哪些注意点:
① 创建对象
② 初始化对象结构
注意点:
1.构造器没有返回值,直接:public Test(){
}
2.关于类的属性的赋值,有几种赋值的方式,谈谈赋值的先后顺序.
默认初始化-显示初始化-构造器初始化,对象.方法或对象.属性给属性赋值.
this关键字可以用来调用哪写结构,简单说明一下其使用.
this:属性,方法,构造器
this理解为当前对象,当前正在创建的对象.
4.Java中目前学习设计到的四种权限修饰符都有什么?并说明各自的权限范围.
public 同一个工程下
protected 不同包下都可以
缺省 同一个包下
private 类内部
5.单例模式.(将构造器私有化)
6.构造器的作用:
1.创建对象
2.初始化对象的信息
next()：
一定要读取到有效字符后才可以结束输入
对输入有效字符之前遇到的空白，next() 方法会自 动将其去掉
只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
next() 不能得到带有空格的字符串
nextLine():
以Enter为结束符，也就是说，nextLine() 方法返 回的是输入回车之前的所有字符
可以获得空格符
public class Person{
String name;
int age;
public void eat(){
sout("吃饭");
}
}
//在另一类中
public class Student extends Person{
public Student(String name,int age){
this.name = name;
this.age = age;
}
}
//测试类中
psvm(){
Student t1 = new Student("zqk",20);
t1.name = "ymm";
t1.eat();
}
//继承性的优点:
1.减少了代码冗余,提高了代码的复用性
2.便于功能的扩展
3.为之后多态性的使用,提供了前提.
二:什么是继承性?
格式:class A extends B{
A:子类/派生类/subclass
B:父类/超类/基类/superclass
一旦子类A继承父类B之后,子类就获取了父类B中声明的结构:所有的(属性/方法)
}
1.特别的:父类中声明私有的属性或方法,仍然认为获取到了父类中的私有的结构,只是因为封装性的影响,使得子类不能直接的调用父类的那个私有的结构(需要也通过get,set方法)
2.子类继承父类以后,还可以声明自己的结构,实现功能的扩展.
3.单继承性:子类只能有一个父类.
父类可以有多个子类.
子类直接继承的父类,称为直接父类;
间接继承的父类称为:间接父类;
子类继承父类以后,就获取了直接父类以及所有间接父类中声明的属性和方法
4.如果没有显示的声明一个类的父类的话，则此类集成于java.lang.Object类
4.所有的java类(处java.lang.Object)都直接或间接的继承于java.lang.Object类
意味着所有的类都具有java.lang.Object的功能
设置断点,进行调试代码.
1.重写:子类继承父类后,可以对父类中同名同参数的方法进行覆盖操作.
2.重写以后,当创建子类对象以后,通过子类对象调用父类的同名参数的方法时,实际执行的时子类重写父类的那个方法.
3.重写的规定:
1.子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符.
2.特殊情况:子类不能重写父类中private声明的方法
3.返回值类型:
>父类中方法返回值是void的话,子类中重写的方法返回值必须是void
>父类中方法返回值类型是A类型,子类中重写的方法返回值只能是A或A的子类
>父类被重写的方法返回值是基本数据类型,则子类中重写的方法返回值类型必须是相同的基本数据类
4.子类重写的方法抛出异常类型不大于父类中被重写的方法抛出的异常.
面试题:区分方法的重写与重载?
重载:是方法的多个形参列表不同,根据你需要的功能需求来调用哪个形参列表的方法.
重写:是子类重写父类中的方法而叫做重写,例如子类对于这个方法需要改进,则就可以写一个跟父类的方法同方法名,同形参列表的方法,叫做重写.
*****************************************
子类和父类中的同名的方法要么都声明为非static的(考虑重写),要么都声明为static的(不是重写)
在不同包下:
1.是另一个包的下的类的子类的话,四种权限可以使用public 和protected
2.不同包下的类是普通的类的话,调用类,只可以使用public声明的属性或方法.
super:理解为父类的
1.使用super.属性/super.方法可以直接调用父类调用父类中的属性方法
2.当子类和父类定义了相同的属性和方法时,想要在子类中调用父类声明的属性时,则必须使用super.属性/方法的方式进行调用父类中的方法.
3.当子类重写父类的方法后,如果想在子类中调用父类的那个被重写的方法的话,可以使用super.被重写的方法来调用父类的方法.
4.super调用构造器
4.1 可以在子类的构造器中显示的使用"super(形参列表)"的方式,调用父类中声明指定的构造器
4.2 super(形参列表)的使用,必须声明在子类构造器的首行!
4.3 在类的构造器中,针对this(形参列表)和super(形参列表)只能二选一,不同同时出现
4.4 在构造器的首行,wwwwww"this(形参列表)"或"super(形参列表)",则默认的调用的是父类中的空参的构造器.
4.5 在类的构造器中,至少有一个类的构造器使用了"super(形参列表)"调用了父类z的构造器.
1.可以理解为一个事物得多种形态.
2.对象的多态性:父类得引用指向子类的对象
Person p1 = new Man();
3.当调用子父类同名参数的方法时,实际执行的是子类重写父类的方法, ----虚拟方法调用
4.多态的使用
有了对象的多态性以后,编译期,只能调用父类中声明的方法,但在执行期执行的是子类重写父类的方法.
5.多态性的使用前提
5.1 类的继承关系,5.2 方法的重写
6.对象的多态性只适用于方法,不适用于属性;
多态是编译时行为还是一个运行时行为?
1.是运行时行为.
Person p1 = new Man();
Man m1 = (man)p1;//强制类型转换,使得m1可以调用自己的属性和方法;也称为向下转型
a instanceof A 是返回true
if(a instanceof A){
sout("----");
}
1.Object类中equals()方法的使用:
Object类中equals()的定义:
public boolean equals(Object obj){
return (this == obj);
}
Object类中equals()和 == 是相同的
但String/Date/File/包装类都重写了Object类中的equals()方法,重写以后比较的就是里面的属性是否相等.
像String,Date,File,包装类中都重写了Object类中的toString方法.
使得在调用toString方法时,返回实体内容.
步骤:
1.选中当前工程 -右键选择:build path - add libraries - Junit 4 - 下一步
2.创建Java类,进行单元测试
此时的Java类要求:1 此类是public的,2此类提供公共的午餐的构造器
3.此类声明单元测试方法
此单元测试方法:方法的权限是public,没有返回值,没有形参
4.此单元测试方法上需要声明注解:@Test,并在单元测试类中导入:import org.junit.Test;
int的包装类位Integer,
基本数据类型===>包装类
例如Integer t1 = new Integer(12);
sout(t1.toString());//输出12
包装类===>基本数据类型Xxx的包装类就用xxxValue方法
int num = t1.intvalue();
sout(num);//输出的就是12
float f1 = t2.floatValue();
char的包装类为Character.
其它的技术数据类型一律是首字母大写.
18万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
