1.Java学习总结

一、第一章

1.Java技术体系平台

1.Java SE 标准版支持桌面级应用 也成为J2SE
1.2Java EE 企业级该技术包含的技术有servlet jsp等,也称J2EE
1.3Java ME现在用的较少了,面向移动端的.

2.Java的重要的特点

    1.Java是面向对象的(oop).Java是健壮的,例如强类型机制,异常处理 垃圾的自动回收等是Java程序健壮性的重要保证.3.Java是跨平台:编译成class文件,既可以在windows上运行,也可以在linux运行,具有跨平台性(底层具有虚拟机,jvm.)4.Java是解释型的解释型语言有:javascipt ,php,java 编译性语言:c/c++
4.          解释性语言编译后的代码不能直接被直接机器执行,还需要解释器来执行,而编译性语言在编译后,是可以直接执行的.

3.跨平台性的原理

因为有了JVM，同一个Java程序在三个不同的操作系统中都可以执行这也就实现了Java的跨平台性
Java的核心机制->Java虚拟机(Java vitral machine)
JVM是一个虚拟的计算机,具有指令集并使用不同的存储区域,负责执行指令,管理数据,内存,寄存器,它包含在JDK中.
不同的平台有不同的虚拟机
Java虚拟机机制屏蔽了底层运行平台的差别,实现了"一次编译,到处运行"

4.什么是JDK,什么是JRE?

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标准库+开发工具集

5.编写最简单的java代码(hello,world)

使用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文件后,再进行执行,才能生效!!

6.Java开发注意事项和细节说明

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和Triggerpublic class Hello{....("hello");}class Dogs{....("Dog");}class Trigger{....("Trigger");}然后将源文件编译:javac Hello.java输出三个后缀名为class的字节符文件.为: Hello.class Dogs.class Trigger.class当你想输出谁的main函数时,直接:java Dogs.class输出: Dogjava Trigger.class输出:Trigger
注意:在命令窗口执行java xxx时,这个类必须有主方法,没有会报错!

7.windows常用的DOS命令

exit:退出
cls:清楚屏幕
dir:列出目录下所有的子目录
cd 目录:进入某个目录

8.java中的注释怎么写?

1.单行注释//
多行注释 /**/
javadoc注释:
/**
*
*
*
*/ =>可以生成帮助文档.

二、第二章(语法基础)

1.标识符

什么是标识符?在源程序中程序员有权利自己有权利命名的单词都是标识符标识符可以标识什么元素呢?类名方法名变量名接口名常量名
2.标识符的命名规则?2.1所有的标识符只能由数字 字母 下划线 美元符号组成,不能含有其它符号不能以数字开头.2.2严格区分大小写2.3关键字不能做标识符2.4理论上无长度限制
3.标识符的命名规范[不属于语法.不遵守规范,不会报错]最好见名知意尊守驼峰命名方式 UserName...类名、接口名: 首字母大写,后面每个单词字母大写变量名、方法名: 首字母小写,后面每个单词首字母大写public static void doSome(){int i = 10;}常量名: 全部大写

2.字面值

字面值: 100,'zbc',true...相当于c语言中的常量!字面值是java程序的组成部分之一,包括标识符和变量名.字面值也分了很多类:整数型字面值浮点型字面值布尔型字面值"abc"/"中国人" :字符串型字面值'A'/'V' :字符型字面值(字符型:单引号中只能存放单个字符)
注意:java语言中所有的字符串字面值必须使用双引号括起来"",java语言所有的字符型字面值必须使用单引号括起来''.

3.变量

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.变量必须先声明,再赋值,才能访问.

3.2 变量

1.方法体中的Java代码是遵守自上而下的顺序依次执行的,方法体中,上面没有执行完,不会往下走.在同一个作用域中,变量名之间不同同名,但可以重新赋值.
2.变量的作用域:什么是作用域?变量的有效范围.出了这个范围,就访问不到了.在指定范围内是可以被访问到的.简单来说,出了大括号就不能访问了.例:public static void main(String[] args){int i = 0;}public static void doSome(){System.out.println(i);//报错}
3.变量的分类:根据变量声明的位置来分类.局部变量:在方法体当中声明的变量叫做局部变量成员变量:在方法体外(类体内)声明的变量叫做成员变量注意:在不同的作用域中变量名是可以相同的,在同一个作用域中,不能重名.在输出某个变量时,遵循就近原则.

4.数据类型

4.1.数据类型的作用?不同数据类型占用的空间大小不同,数据类型的作用是指导JVM在运行程序时给该数据分配多大的内存空间.
4.2java中的数据类型包括两种:基本数据类型:包括四大类,八小种:第一类: 整数型byte,short,int,long第二类: 浮点型float,double第三类: 布尔型boolean第四类: 字符型char引用数据类型:类接口数组[String]....
4.3字符串("..")不属于基本数据类型.属于引用数据类型
4.4八中数据类型占用的大小为多少?基本数据类型        占用空间大小[单位:字节]---------------------------------------byte                 1short                2int                  4long                 8float                4 double               8 boolean              1char                 2 字符型4.4.1计算机只能识别二进制.4.4.2字节:1个字节等于8个比特位(例:10010101):1 byte = 8 bit一个比特位就是一个二进制位1KB = 1024byte1MB = 1024KB1GB = 1024MB1TB = 1024GB1TB = 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'为编码,解码和编码采用的是同一个对照表.

5.字符编码

简体中文的编码方式:GB2312 < GBK < GB18030 //内从小到大.
繁体中文:bjg5
unicode编码方式:统一了全球所有的方式.UTF-8UTF-16UTF-32
java语言采用unicode编码方式,所以"标识符"可以用中文
现在实际开发中,UTF-8开发项目较多.

6.八种基本数据类型的取值范围

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)

7.八种数据类型的默认值

"成员"变量没有赋值时,系统会默认赋值.局部变量不会
数据类型                  默认值
---------------------------------
byte、short、int、long     0
float、double             0.0
boolean                   false   [false也相当于0，true为1]
char                      \u0000
八种数据类型的默认值都向0看齐

8.字符型char(单引号)

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进制,表示"中"

9.整数型(byte,short,int,long)

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在取值范围内,可以直接赋值整数型字面值.不用加强制类型转换.

10.浮点型

float  单精度【4个字节】
double 双精度【8个字节,精度较高】
double相对于银行数据来说,精度太低.不适合做财务软件.所以SUN在基础SE类库当中准备了精确度更高的引用数据类型.是java.math.BigDecimaljava提供了一套庞大的类库.java程序员是基于这套基础的类库来开发的,所以要知道java的SE类库的字节码在哪.要知道javaSE的源码在哪SE类库字节码: C:\Program Files\Java\jdk1.8.0_152\jre\lib\rt.jarSE类库源码: C:\Program Files\Java\jdk1.8.0_152\src.zip10.2所有的浮点型字面值[3.0],默认值被当作double类型来处理,
要想该字面值当作float类型来处理,需要在字面值后面添加F/fdouble b = 3.0;float f = 5.1;//编译错误.5.1是double类型,将其赋值给float类型,报错. 第一种方案:float f = (float)5.1;(强制类型转换)第二种方案:float f = 5.1f;(没有强制转换)
注意:double和float在计算机当中存储的都是近似值.因为现实世界有些是无限循环的,例如:3.333...所以存储无限的数据只能存储近似值.

11.布尔类型

在java中booleanl类型只有两个值,true和false,没有其它值.boolean flag = 1;//报错,不兼容.boolean flag = true;if(flag){System.out.println("成功")}else{System.out.println("失败")}

12.基本数据类型转换规则

转换规则:1.八种基本数据类型当中除布尔类型之外,剩下的7种数据类型之间都可以互相转换.2.小容量向大容量转换.称为自动类型转换.容量从小到大:byte<short<int<long<float<doublechar<注:任何浮点类型不管占用多少个字节,都比整数型容量大.char和short可表示的种类数量相同,但是char可以取更大的正整数.char c = 97;//成功3.大容量转换成小容量,一般都得强制类型转换,需要加强制类型转换符,程序才能编译通过,但在运行阶段可能会损失精度.谨慎使用!!4.当整数型字面值没有超过byte,short,char的取值范围时,可以直接将int类型的字面值赋值给byte,short,char类型的变量5.byte,short,char在进行混合运算时,各自先转换成int类型,在做运算.6.多种数据类型混合运算,先转换成容量最大的那种数据类在做运算.

13.数据类型的题型巩固

13.1int f = 10/3;//编译成功,输出为3
13.2double d = 10/3;//输出为3.0,因为右边的int类型先进行运算,然后再转换为double类型,为3.0
13.3double 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.运算符

14.1算术运算符+、-、*、/、%、++、--++运算符：可以出现在变量前，也可以出现在变量后。14.1.1出现在后?int a = 100;int b = a ++;输出a,ba输出为101，b输出为100,由于是a++,所以先进行赋值运算,然后进行自身的++,所以b为100,a为101.14.1.2出现在前?int a = 100;int b = ++ a;输出a,ba输出为101，b输出为101,由于是++a,所以先进行自身的++,然后再进行赋值运算,所以b为100,a为101.--亦是如此.14.1.3int i = 100;System.out.println(i ++);//输出100System.out.println(i);//输出101关系运算符逻辑运算符字符串连接运算符三元运算符赋值类运算符

15.关系运算符

>
>=
<
<=
==
!=注意:=是赋值运算符;关系运算符的运算结果一定是布尔类型:true/false

16.逻辑运算符

逻辑运算符:&    逻辑与   (两边的算子都是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.运算符

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三目运算符/三元运算符

18.字符串连接运算符(“+”)

1.当"+"运算符只要两边的数据有一个是字符串的话,一定会进行字符串拼接.
2.例如你定义两个变量，a,b,输出为a+b=(a+b)的形式，你需要进行字符串拼接：System.out.println(a+"+"+b+"="+(a+b));这样进行输出，就可以进行字符串的拼接。
3.引用数据类型:String,SUN公司在javaSE当中提供的字符类型.String s = "abc";

19.三元运算符/三目运算符/条件运算符

语法:布尔表达式?表达式1:表达式2;当布尔表达式的结果为true时,选择表达式1作为整个表达式的执行结果.当布尔表达式的结果是false时,选择表达式2作为整个表达式的执行结果.boolean sex = false;String i = sex ? "男": "女";注意:char c1 = sex ? "男":'女'; //编译错误,语法错误,sex值不确定,后面是string类型和字符类型,不能赋值给字符型类型.

20.控制语句

选择结构:20.1.1if  if...elseif语句的特点,只要一个分支执行,整个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;//设置一个旗帜,标志是否进入第一个ifif(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.4if(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;switchswitch语句也属于选择结构,也是分支语句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.for1.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;//重置是否换行旗帜}}}}} while1.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;}}continuecontinue:表示下一个:continue表示直接进入下一个循环继续.break与continue的区别?break直接全部结束最近的循环.continue是结束本次循环语句,继续跳到下一次循环.

21.方法

方法的基础语法:如果有好几段代码几乎相同,就是一些参数不同,就可以写在方法里,代码复用.减少了代码重复程度,提高的效率.方法的本质就是代码片段,可以完成某个特定的功能,并且可以重复使用.    方法对应的单词为: Method方法在C中叫做: 函数/Function方法定义在类体当中,一个类可以定义多个方法.编写的位置没有先后顺序,可以随意.只要带有return关键字的语句执行后,方法结束!不再执行这个方法.** 方法体中不能再定义方法!!方法名使用小驼峰命名法.2.方法的重载:onload

22.衡量一个功能代码的劣势

1.正确性
2.可读性
3.健壮性
4.高效率与低存储:时间复杂度* 空间复杂度(衡量一个算法的标准)

23.eclipse的使用

不要在工作空间时点击默认这个工作空间.
搜索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.数组

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

25.二维数组

  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.0char:0(ASCII值为0)boolean:false引用数据类型:null

26.数据结构

1.数据与数据之间的逻辑关系:集合,一对一,一对多,多对多
2.数据的存储结构:2.1线性表:顺序表(例:数组),链表,栈,队列.2.2树形结构:二叉树2.3图形结构:26.2算法:排序算法:搜索算法:

27.复习

  1.如何理解二维数组?数组属于引用数据类型.数组的元素也可以是应用数据类型.一个一维数组A的元素如果还是一个一维数组类型的,则称A称为二维数组.2.1String[][] str2 = new String[3][];2.2String[][] str2 = new String[3][2];//第二个中括号指定一个固定长度与不指定一个固定长度的区别://指定一个长度,代表会在内存空间开辟一个数组的空间,然后将地址值存入一维数组对应里,这样,你去访问时,它返回的就是一个地址值(没有赋值)//没有指定长度,则只能说明你的一维数组中的元素是数组,但没有在内存中开辟空间,所以此时访问,为null.

28.数组练习

声明: 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;

29.数组中常见的算法

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-1int 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;}}}衡量排序算法的优劣:时间复杂度**,空间复杂度,稳定性

30.Arrays工具类的使用

 定义在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) 对排序后的数组进行二分法检索指定的值

31.数组中常见的异常

  1.ArrayIndexOutOfBoundsException:数组角标越界异常.合理范围:[0-length-1],其它的都是越界2.NullPointerException:空指针异常2.1int[] arr = null;arr[0];//空指针异常2.2 int[][] arr = new int[4][];arr[0][0];//报错.空指针一旦程序出现异常,未处理则,终止运行.

二 面向对象

1.面向对象的学习主线

 1.三条主线:Java类及类的成员:属性,方法,构造器;代码块,内部类面向对象的三大特征:封装性,继承性,多态性,(抽象性)其它关键字:this,super,static,final,abstract,interface,package,import

2.面向对象的要素

    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方法中不可以定义方法.

3.面向对象编程学生类例子

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.总结

4.1面向对象思想编程内容的三条主线分别是什么?① 类及类的成员: 属性,方法,构造器; 代码块,内部类② 面向对象的三大特征: 封装,继承,多态③ 其它关键字:this,super,abstract,interface,final,package...③ 面向对象的编程思想?(类和对象的概念,面向对象的三大特征,接口....)
4.2谈谈你对面向对象中类和对象的理解,并指出二者的关系?类:对事物的描述,抽象的,概念上的内容.对象:实实在在存在的一个个体.对象是由类new出来或派生出来的.4.3类和对象的创建和执行操作有哪三步？① 创建类② 类的实例化③ 通过调用对象的结构：对象.(属性/方法)4.4类的方法内是否可以定义变量,是否可以调用属性?是否可以定义方法?是否可以调用方法?可以定义变量,可以调用属性,不可以定义方法,可以调用方法.<<JVM规范>>

5.理解"万事万物皆对象"

 在java语言范畴中,我们将功能结构等封装到类中,通过类的实例化,来调用具体的功能结构.2.Java语言与前端和数据库交互时,都体现为类,对象.

6.匿名对象的使用

 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());//匿名对象的使用.}

7.自定义ArraysUtil工具类的使用

 1.ArraysUtil类:package com.zqk.day04;import sun.security.util.Length;/*** ClassName:ArraysUtil* PacKage:com.zqk.day04* Description:** @Date:2022/4/10 23:44* @Athor:zqkyy email:zqkqk@qq.com*/
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;/*** ClassName:ArraysUtilTest* PacKage:com.zqk.day04* Description:** @Date:2022/4/10 23:49* @Athor:zqkyy email:zqkqk@qq.com*/
public class ArraysUtilTest {public static void main(String[] args) {ArraysUtil au1 = new ArraysUtil();//创建自己定义的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 }
}

8.方法的重载

定义:在同一个类当中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可.两同一不同:同一个类,相同方法名参数列表不同:参数个数不同:参数类型不同:public void getSum(int i,String s){...}public void getSum(String s,int i){...}public void getSum(double b,int i){...}判断是否是重载:跟方法的权限修饰符,返回值类型,和形参的名字都没有关系.4.在通过对象.方法名时,如何确定一个指定的方法,① 方法名② 参数列表

9.可变个数形参的方法(0-多个)

格式: 数据类型 ... 形参名
public void show(String ... strs){}
//调用
show();
show("zqk");
show("zqk","ymm");
//可变形参必须放在最后
2.public void getSum(int i,String ... str){}

10.方法参数的传递机制********

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);//输出为m为:20-n为:10,即为

11.网红题

 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);//输出什么?

12.递归

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总结:

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();//调用first方法.}public void first(){int i= 5;//first中设置的一个局部变量为 i= 5;Value v = new Value(); //创建Value的对象v.i = 25; //使其这个v对象的i为5second(v,i); //调用second方法,将其v变量存储的地址值,i为5带入,System.out.println(v.i);//输出v,i;v为创建的这个对象,但在调用second时,将其i改变为20,所以输出为20}public void second(Value v,int i){//带入v(i为25)的地址值(即操作的是同一个对象)和i = 5i = 0; //再将其second中i变量变为0v.i = 20; //将其这个second中的形参赋值,也就是将其v的值与first中的v地址值一样,所以操作的就是同一个对象,将其i变为20;Value val  =new Value(); //再创建Value的对象v = val; //将其v重新设置值为val的地址值System.out.print(v.i+" "+i+" "); //输出v.i和i,即为15和0}/*** 所以最后输出为15 0 20*/}class Value{int i =15;}
1.内存结构:栈(局部变量),堆(,new出来的结构对象(成员变量),数组)
2.变量:成员变量vs局部变量(方法你,方法形参,构造器内,构造器形参,代码块内)面试:方法的重载与重写的区别？throws\ throw String\ StringBuffer\ StringBuilderCollection\ Collectionsfinal \ finally\ finalize抽象类 \ 接口sleep() \ wait()*** 可变形参的格式:(String ... strs)注意:可变形参只能放在最后:(String str,String ... strs);//正确(String ... strs,String str);//错误,不能将可变形参放在前面.

14.封装性

面向对象的特征之一:封装与隐藏.例如:现在我们需要你个Animal的类,里面设有name,age,legs等属性,还有showFeild方法,是输出这个类的基本属性的.2.我们在实例化这个类时,通过调用legs属性给其赋值.(其中legs代表的是动物的腿的个数),但由于现实世界中腿的个数不可能为0或者为负数,所以用户可能给其赋值其负数,为了避免这个问题,我们可以再设一个方法,专门给其legs赋值,在此之前进行判断调用的这个方法的参数是否大于0;3.赋值以后可以实现我们的目标,但是还可以调用之前的legs进行赋值,为了避免这个问题,我们需要将legs不向外暴露,即需要添加private修饰,所以在这就体现了封装性.class Animal{ //定义一个类String name;int age;private int legs; //私有属性legspublic 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会为0a1.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提供了四种权限修饰,来修饰类及类的内部结构,体现了其可见性的大小.
封装性的简单点来说,就是把该隐藏的隐藏起来,该暴露的暴露起来,这就是封装性的设计思想.

15.构造器

构造器(构造方法) constructor1.构造器的作用:用来创建对象(new + 构造器).如果没有现实定义类的构造器的话,系统默认提供一个空参的构造器2.定义构造器: 权限修饰符 类名(构造器名)(形参列表){}3.构造器的作用:1.创建对象2.初始化对象的信息3.一个类中定义的多个构造器,彼此构成重载.4.一旦显示的定义了类的构造器之后,系统就不会再提供空参构造器.5.一个类中,至少会有一个构造器.

16.JavaBean的使用

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;}}

17.this的使用

this理解为当前对象.this可以修饰:属性,方法,构造器在类的方法中,可以使用this.属性或this.方法的方式.比如Person p1 = new Person();① 则在类中使用的this就代表p1② 使用this.变量,的方式,表明此变量是属性,而非形参③ 如果你使用this来调用构造器的话,使用this(与构造器形参列表相同);的形式来调用构造器,(在构造器里不能调用自己,否则一直调用自己,出不去了.)25④ 构造器中不能通过"this(形参列表)"来调自己.⑤ 如果一个类中有n个构造器,则最多有n-1个构造器使用this⑥ 规定:"this(形参列表)"必须声明在当前构造器的首行.⑦ 构造器内部:最多声明一个"this(形参列表)"用来调用其它的构造器.

18.leetcode编程题总结

/*** 一只青蛙想要过河。 假定河流被等分为若干个单元格，并且在每一个单元格内都有可能放有一块石子（也有可能没有）。* 青蛙可以跳上石子，但是不可以跳入水中。* * 给你石子的位置列表 stones（用单元格序号 升序 表示）， * 请判定青蛙能否成功过河（即能否在最后一步跳至最后一块石子上）。* 开始时， 青蛙默认已站在第一块石子上，并可以假定它第一步只能跳跃 1 个单位（即只能从单元格 1 跳至单元格 2 ）。** 如果青蛙上一步跳跃了 k 个单位，那么它接下来的跳跃距离只能选择为 k - 1、k 或 k + 1 个单位。 * 另请注意，青蛙只能向前方（终点的方向）跳跃。** 示例 1：* 输入：stones = [0,1,3,5,6,8,12,17]* 输出：true* * 解释：青蛙可以成功过河，按照如下方案跳跃：跳 1 个单位到第 2 块石子, 然后跳 2 个单位到第 3 块石子, * 接着 跳 2 个单位到第 4 块石子, 然后跳 3 个单位到第 6 块石子, 跳 4 个单位到第 7 块石子, * 最后，跳 5 个单位到第 8 个石子（即最后一块石子）。*/
public class CanGetRiver {public static void main(String[] args) {int priDis = 0, jumpStage = 0; //pri代表现在在石头的位置的编号,jump代表跳到这个石头上的步数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;//刚开始站在第一个石头上，为truefor (int i = 1; i < n; i++) {int j = i - 1;/*** 当你在第0项石头的时候因为你的跳的步数为0,你只能跳-1,0,1步,也就是只能往前跳一步,到达第一项的石头* 在第一项,以上一个步数为1,所以你只能跳0,1,2,也就是第一项最大数为2,到达第二项时最大石头编号为3,* 第二项时,步数为2,所以你只能跳1,2,3,也就是第二项最大步数为3* 即当你的k(为当前石头和上一次石头的步数) > 上一次石头加一时,就不可能跳过去.*/int k = stones[i] - stones[j]; //k为当前石头和前一个石头的步数大小if (k > j + 1) {//如果k大于它在起跳时的那个石头的编号加一时(也就是上方注释所说),直接跳出循环break;}if (k + 1 <= n - 1) { //如果你的k+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;}
}

19.练习this

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);/* Girl girl1 = new Girl("袁梦梦2号",20);int compare =  girl.compare(girl1);if(compare > 0){
System.out.println(girl.getName()+" 大");}else if(compare<0){
System.out.println(girl1.getName()+" 大");}else {
System.out.println("一样大");}*/
}
}

20.package import的使用

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

21.MVC的设计模式

model-view-controller

22.问题总结

 1.构造器的作用是什么?使用时有哪些注意点:① 创建对象② 初始化对象结构注意点:1.构造器没有返回值,直接:public Test(){}2.关于类的属性的赋值,有几种赋值的方式,谈谈赋值的先后顺序.默认初始化-显示初始化-构造器初始化,对象.方法或对象.属性给属性赋值.this关键字可以用来调用哪写结构,简单说明一下其使用.this:属性,方法,构造器this理解为当前对象,当前正在创建的对象.4.Java中目前学习设计到的四种权限修饰符都有什么?并说明各自的权限范围.public 同一个工程下protected  不同包下都可以缺省 同一个包下private 类内部5.单例模式.(将构造器私有化)6.构造器的作用:1.创建对象2.初始化对象的信息

23.next()与nextLine()的区别

     next()：一定要读取到有效字符后才可以结束输入对输入有效字符之前遇到的空白，next() 方法会自   动将其去掉只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符next() 不能得到带有空格的字符串nextLine():以Enter为结束符，也就是说，nextLine() 方法返    回的是输入回车之前的所有字符可以获得空格符

24.继承性

 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:子类/派生类/subclassB:父类/超类/基类/superclass一旦子类A继承父类B之后,子类就获取了父类B中声明的结构:所有的(属性/方法)}1.特别的:父类中声明私有的属性或方法,仍然认为获取到了父类中的私有的结构,只是因为封装性的影响,使得子类不能直接的调用父类的那个私有的结构(需要也通过get,set方法)2.子类继承父类以后,还可以声明自己的结构,实现功能的扩展.3.单继承性:子类只能有一个父类.父类可以有多个子类.子类直接继承的父类,称为直接父类;间接继承的父类称为:间接父类;子类继承父类以后,就获取了直接父类以及所有间接父类中声明的属性和方法4.如果没有显示的声明一个类的父类的话，则此类集成于java.lang.Object类4.所有的java类(处java.lang.Object)都直接或间接的继承于java.lang.Object类意味着所有的类都具有java.lang.Object的功能

25.eclipse-debug调试.

 设置断点,进行调试代码.

26.方法的重写(override/overwrite)

 1.重写:子类继承父类后,可以对父类中同名同参数的方法进行覆盖操作.2.重写以后,当创建子类对象以后,通过子类对象调用父类的同名参数的方法时,实际执行的时子类重写父类的那个方法.3.重写的规定:1.子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符.2.特殊情况:子类不能重写父类中private声明的方法3.返回值类型:>父类中方法返回值是void的话,子类中重写的方法返回值必须是void>父类中方法返回值类型是A类型,子类中重写的方法返回值只能是A或A的子类>父类被重写的方法返回值是基本数据类型,则子类中重写的方法返回值类型必须是相同的基本数据类4.子类重写的方法抛出异常类型不大于父类中被重写的方法抛出的异常.面试题:区分方法的重写与重载?重载:是方法的多个形参列表不同,根据你需要的功能需求来调用哪个形参列表的方法.重写:是子类重写父类中的方法而叫做重写,例如子类对于这个方法需要改进,则就可以写一个跟父类的方法同方法名,同形参列表的方法,叫做重写.*****************************************子类和父类中的同名的方法要么都声明为非static的(考虑重写),要么都声明为static的(不是重写)

27.四种权限修饰符

 在不同包下:1.是另一个包的下的类的子类的话,四种权限可以使用public 和protected2.不同包下的类是普通的类的话,调用类,只可以使用public声明的属性或方法.

28.super关键字

 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的构造器.

29.多态性–>对象的多态性

 1.可以理解为一个事物得多种形态.2.对象的多态性:父类得引用指向子类的对象  Person p1 = new Man();3.当调用子父类同名参数的方法时,实际执行的是子类重写父类的方法, ----虚拟方法调用4.多态的使用有了对象的多态性以后,编译期,只能调用父类中声明的方法,但在执行期执行的是子类重写父类的方法.5.多态性的使用前提5.1 类的继承关系,5.2 方法的重写6.对象的多态性只适用于方法,不适用于属性;

30.面试题

 多态是编译时行为还是一个运行时行为?1.是运行时行为.

31.如何调用子类特有的属性和方法?

 Person p1 = new Man();Man m1 = (man)p1;//强制类型转换,使得m1可以调用自己的属性和方法;也称为向下转型

32.instanceof关键字使用

 a instanceof A  是返回trueif(a instanceof A){sout("----");}

33.Object的使用

1.Object类中equals()方法的使用:Object类中equals()的定义:public boolean equals(Object obj){return (this == obj);}Object类中equals()和 == 是相同的但String/Date/File/包装类都重写了Object类中的equals()方法,重写以后比较的就是里面的属性是否相等.

34.Object类z和toString的使用

 像String,Date,File,包装类中都重写了Object类中的toString方法.使得在调用toString方法时,返回实体内容.

35.单元测试方法的使用

 步骤:1.选中当前工程 -右键选择:build path - add libraries - Junit 4 - 下一步2.创建Java类,进行单元测试此时的Java类要求:1 此类是public的,2此类提供公共的午餐的构造器3.此类声明单元测试方法此单元测试方法:方法的权限是public,没有返回值,没有形参4.此单元测试方法上需要声明注解:@Test,并在单元测试类中导入:import org.junit.Test;

36.包装类

 int的包装类位Integer,基本数据类型===>包装类例如Integer t1 = new Integer(12);sout(t1.toString());//输出12包装类===>基本数据类型Xxx的包装类就用xxxValue方法int num = t1.intvalue();sout(num);//输出的就是12float f1  = t2.floatValue();char的包装类为Character.其它的技术数据类型一律是首字母大写.

Java学习总结与体会，从小菜开始相关推荐

1. java学习之心得体会

   面临毕业与就业的压力,不久将来就要从一个学生到一个社会人的转变:技术在不断的提高,思路在不断的开阔,思想在不断的升华,更重要的是自己的理想和抱负更加的坚定.对于一个投身于IT的新人,经验谈不上,一些学 ...

2. 关于Java学习的心得体会

   大一的第二学期,满心欢喜的期待着自己的专业课,上个学期C语言老师和我们说C语言只是入门,我们还学得如此吃力.心中已经能够想到本学期的心酸了,果不其然,老师说本学期不学C++了,要教我们学JAVA,说完 ...

3. 我学习 Java 的历程和体会（写给新手看，欢迎老司机批评和建议，持续更新中）

   我学习 Java 的历程和体会(写给新手看,欢迎老司机批评和建议,持续更新中) 最初写这篇文章的时候,是在今年的 9 月中旬.今天,我想再写写这将近两个多月以来的感受. 在今年的 10 月我来到北京求 ...

4. 关于java学习体会心得

   关于初次学习java,在python的基础上,学习java,但是学习起来还是很困难.对于学习的列表.字典.循环等,在python中学习很差,所以导致java学习比较难. 在面向程序时,比较容易学习,但 ...

5. C#线程学习的一点体会和总结

   C#线程学习如同在Java中一样,在c#中写一个多线程应用是非常简单的,本章将介绍如何在c#种开发多线程程序.在.net中线程是由System.Threading 名字空间所定义的.所以你必须包含这个 ...

6. Spring源码学习的初步体会

   Spring源码学习的初步体会: 深入学习和巩固java的基础知识,其中的java知识范围全部,可以边研究源码边巩固复习基础知识 体会其中用到的设计思想:其中包含的设计原则和设计模式. 加深对spri ...

7. java关于泛型的实验代码_[ Java学习 ] 泛型类的应用实验

   成文原因: 这篇文章是我这周所做的 Java 实验题的一个小总结. 这次实验让我深刻赞同了我们 Java 老师在这节实验课前告诉我们的话: 最重要的是把问题想明白,它要怎么拆分成几个类,每个类里究竟需 ...

8. 计算机编程老鸟的心得,java入门123——一个老鸟java学习心得.docx

   java入门123--一个老鸟的java学习心得 学习Java心得体会 学习了一学期的Java课程,觉得是该总结自己的心得体会了.开始学习任何一门课(包括java),兴趣最重要.一直觉得自己在学计算机 ...

9. java老鸟123怎么样_java入门123——一个老鸟的java学习心得.doc

   java入门123--一个老鸟的java学习心得 java入门123--一个老鸟的java学习心得 篇一:java初学者学习心得 学习Java心得体会 学习了一学期的Java课程,觉得是该总结自己的心 ...

最新文章

1. 面试官：为什么MySQL的索引要使用B+树，而不是其它树？比如B树？
2. Python_note9 Matplotlib画图 Seaborn画图
3. myeclipse上进行tomcat远程调试
4. hid编程 qt_hidapi-0.7.0 OS Develop 操作系统开发 240万源代码下载- www.pudn.com
5. 分布式任务调度平台XXL-JOB一
6. 什么时候出来的_DNF手游官网正版什么时候出来？地下城手游上线日期分享
7. Tensorflow卷积神经网络
8. SpringBoot 简单实现仿CAS单点登录系统
9. layui鼠标放上图片局部放大_老照片修复教程之—裁剪图片大小
10. 微软发布 Autodesk FBX 漏洞带外安全公告，将于5月推出补丁
11. 《嵌入式 – GD32开发实战指南》第5章 跳动的心脏-Systick
12. 自己动手写打印机监控程序
13. 今天来看一下云测平台的测试实验
14. 信度spss怎么做_Spss详细图文教程——问卷信度和效度检验步骤图解
15. PHP的性能演进(从PHP5.0到PHP7.1的性能全评测)
16. android-c2手机,Nokia C2手机亮相：搭载紫光展锐处理器
17. 一张图架构示意图及简单分析
18. 联通集团入选混改试点：电联合并已无希望
19. S905L（P211）盒子刷android tv以及刷emuelec 4.4/4.5的向导/方法
20. 学术论文rebuttal

热门文章

1. 2018北京理工大学电子设计大赛总结
2. [ArcGIS]ArcGIS SceneView视图下浏览器环境设置
3. Kodein在ktor中的使用
4. 网上打印文件推荐哪一个软件好
5. GAN Dissection: Visualizing and Understanding Generative Adversarial Networks
6. 【智慧城市】国内领先水平！智慧柳州时空云平台是怎样炼成的？
7. 差模信号、共模信号、共模抑制比的概念
8. 方舟一直显示服务器崩溃,疑问：方舟265更新后进服务器游戏崩溃
9. 理论+实验 详解MySQL全量，增量备份与恢复
10. R语言计算mae,mape,欧氏距离，rmse