Java自学后的前十章练习题及实时复习
各章重点知识的总结及回顾
Java执行是从 main 方法开始执行的，此方法的完整定义是 public static void main(String[]args) { }
Java类名的每个单词的首字母通常要求 小写 。
简述Java实现可移值性的基本原理。
答;Java属于编译型和解释型的编程语言，所有的*.java程序必须编译为*.class文件之后才可以在电脑上执行，而执行x.class文件的电脑并不是一台真实的电脑，而是利用软件和硬件模拟出来的一台虚拟电脑，称为Java虚拟机，而针对于不同的操作系统平台，有不同版本的Java虚拟机，即：由Java虚拟机去适应不同的操作系统，即：只要Java虚拟机的支持没有改变，同一个x.class可以在不同的平台上运行
简述Java中path及classpath的作用。
答: PATH：是操作系统的环境属性，指的是可以执行命令的程序路径；
CLASSPATH：是所有x.class文件的执行路径，java命令执行的时候将利用此路径加载所需要的x.class文件。
详细阐述Java中使用public class或class声明一个类的区别及注意事项。
答:使用public class定义的类，要求文件名称和类名称保持一致，在一个*.java文件之中只能存在一个public class；
使用class定义的类，文件名称可以和类名称不一致，在一个x.java文件之中可以同时存在多个class定义，编译之后 会产生多个x.class文件。
请解释“&”和“&&”的区别？
答:&在进行逻辑运算时表示所有判断条件都需要判断，而“&&”为短路与，在前面的判断返回false时后面判断将不再执行，最终的结果就是false。
&还可以应用在位操作上。
请解释“|”和“||”的区别？
答:|在进行逻辑运算时表示所有判断条件都需要判断，而“|”为短路或，在前面的判断返回true时后面判断将不再执行，最终的结果就是true。
|还可以应用在位操作上。
基本数据类型不牵扯到内存开辟的问题,而引用数据则关系到内存
java基本数据类型的大小,方法与默认值整型：
byte：-2^7 ~ 2^7-1，即-128 ~ 127。1字节。Byte。末尾加B
short：-2^15 ~ 2^15-1，即-32768 ~ 32767。2字节。Short。末尾加S
有符号int：-2^31 ~ 2^31-1，即-2147483648 ~ 2147483647。4字节。Integer。
无符号int：0~2^32-1。
long：-2^63 ~ 2^63-1，即-9223372036854774808 ~ 9223372036854774807。8字节。Long。末尾加L。（也可以不加L）
浮点型：
float：4字节。Float。末尾加F。（也可以不加F）
double：8字节。Double。
字符型：
char：2字节。Character。
布尔型：
boolean：Boolean。
数据类型转换
范围小的数据类型可以自动转为范围大的数据类型,而范围大的到小的则需要强行转换
Java中一些命名规范:*类名的命名要遵循首字母大写原则，类的名字必须由大写字母开头而单词中的其他字母均为小写；如果一个类名称是由多个单词组成，则每个单词的首字母均应为大写例如ModelWhAction；如果类名称中包含单词缩写，则这个所写词的每个字母均应大写，如：XMLExample,还有一点命名技巧就是由于类是设计用来代表对象的，所以在命名类时应尽量选择名词 变量的命名要遵循通俗易懂的原则，比如名字就用 name ，而不是用a、b、c这样的命名。变量命名除了变量名外，实例，包括类、类常量，均采用大小写混合的方式，第一个单词的首字母小写，其后单词的首字母大写。变量名不应以下划线或美元符号开头，尽管这在语法上是允许的。但是在工作中这样做会降低代码的可阅读性，在工作上这是不规范的.使用驼峰命名法命名多个单词组成的变量名。
方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头。
需要用到的变量命名和方法命名要遵循首字母小写原则，如果名称是由多个单词组成，每个单词的首字母都要大写（除首个单词）。
所有命名规则必须遵循以下规则：
1)、名称只能由字母、数字、下划线、$符号组成 2)、命名时不能以数字开头 3)、在命名是绝对不能出现Java关键字。
方法重载:方法名称相同,参数类型或者个数不同, 判断: 定义多个同命方法时,可以依靠返回值区别同名方法(x) 2 在进行方法重载时返回值类型必须相同,否则无法通过程序的编译.(x)
方法递归调用是指:本方法自身重复执行,在使用递归调用时一定设置好方法的结束条件,否则会出现内存溢出问题,造成程序的中断.
java中的流程控制
- 1 用户交互Scanner(java.util.Scanner)
输入语句Scanner:是从jdk 1.5开始追加
主要目的:为了解决输入流的访问问题,可以理解为BufferedReader的替代功能类.
基本的语法
Scanner s = new Scanner(System.in);通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判读是否还有输入的数据
构造Scanner类对象，它附属于标准输入流System.in
相关用代码实现
import java.util.Scanner; public class JavaIODemo{
public static void main(String[]args){
Scanner scan = new Scanner(System.in);//创建输入流对象
System.out.println(“请输入年龄:”);//提示信息
if (scan.hasNextInt())//判断是否整数输入
{
int age = scan.nextInt();//直接获取数字
System.out.println(“年龄:”+age);//数据回显
}else{
System.out.println(“输入的内容不是数字,程序无法正常运行!!”);//错误提示
}
scan.close();//关闭输入流
}
}<img src="C:\Users\阿旺\AppData\Roaming\Typora\typora-user-images\image-20201017102831611.png" />输出语句
- System.out.println();//换行打印
- System.out.print();//不换行打印
- System.out.write();//字节输出
- System.out.printf("%+8.3f/n",3.4);//按格式输出
常用的next()方法系列：
- nextInt():输入整数
- nextLine():输入字符串
- nextDouble():输入双精度数
- next():输入字符串（以空格作为分隔符）
next()与nextLine()的区别:
- x.next()
- 一定要读取到有效字符后才会结束输入
- 对输入的有效字符之前遇到的空白，next()方法会自动将其去掉
- 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
- next()不能得到带有空格的字符串
- x.nextLine():
- 以Enter为结束符，nextLine（）方法返回的是输入回车之前的所有字符
- 可以获得空白
2 顺序结构:
JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序从上往下执行
顺序结构是最简单的算法结构，顺序结构是任何一个算法都离不开的一种基本算法结构
语句与语句，代码块与代码块之间按照从上往下的顺序执行，由若干个依次执行的处理步骤组成
3 选择结构
if单选择结构
if(布尔表达式){
//如果布尔表达式为true将执行的语句
}if双选择结构
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}if多选择结构
if(布尔表达式 1){ //如果布尔表达式1的值为true执行代码 }else if(布尔表达式 2){ //如果布尔表达式2的值为true执行代码 }else if(布尔表达式3 ){ //如果布尔表达式3的值为true执行代码 }else{ //如果以上比尔表达式都不为true执行代码 }嵌套的if结构
if(布尔表达式 1){ //如果布尔表达式1 的值为true执行代码 if(布尔表达式 2){ //如果布尔表达式2 的值为true执行代码 } }总结:
if语句至多有一个else语句，else语句在所有的else if之后，if语句可以有若干个else if语句，它们必须在else语句之前。一旦其中的一个else if语句为true，其它的else if语句以及else 语句都将跳过执行
switch多选择结构
switch 语句中的变量类型可以是:byte、short、int、或者char
从java SE 7开始支持字符串String类型
case标签必须为字符串常量或字面量
如果不写break，程序就会继续往下面的执行，产生case穿透
switch(expression){ case value: //语句 break;//可选 case value: //语句 break;//可选 default://可选 //语句 }
- 4 循环结构
while循环
while(布尔表达式){
//循环内容;
}总结;
- 只要布尔表达式为true，循环就会一直执行下去，当表达式不成立，则跳出循环
- 对于while语句而言，如果不满足条件，就无法进入循环
- 循环条件如果一直为true就会造成无限循环（死循环），会影响程序性能或者造成程序卡死崩溃!!!
do…while循环
do{ //代码语句 }while(布尔表达式);for循环
//初始化//条件判断//迭代
for(初始化;布尔表达式;更新){ //代码语句 }总结:
- for循环是支持迭代的一种通用结构，一种有效、灵活的循环结构
- 初始化语句可以为空，也可以初始化一个或多个循环控制变量
- 如果布尔表达式的值为true，循环体被执行，false则结束循环，继续执行程序后面的语句
- 执行一次循环后，更新循环控制变量，再次检测布尔表达式。循环执行上面的过程.
- 5 语句问题
break:当程序运行到break语句时,立即会离开循环,执行循环外的语句,如果break语句出现在嵌套循环的内岑循环,则break语句只会逃离当前层循环.
continue:强制程序跳到循环的起始处,也就是当程序运行到continue语句时,立即会停止运行剩余的循环主体,而回到循环的开始处执行.
return:中断程序的执行.
练习::九九乘法表
public class For99chengfa
{
public static void main(String[]args){
//9行 9 次循环
for (int i=1;i<=9 ;i++ )//纵向循环9次
{
//System.out.println(i);//i是行号(1~9)
//负责输出一行 (内部for循环负责将一行上的全部输出)
for (int j=1;j<=i ;j++ )//循环几次与行号有关系 即i是行号
{
System.out.print(j+"*"+i+"="+i*j +" ");//这里不能换行 //这里加了空格
}
//换行
System.out.println();
}
}
}
Java面向对象的编程
对象的创建
面向过程：当需要实现一个功能时，每个具体的步骤都要亲力亲为，详细处理每个细节。（强调过程）
面向对象：当需要实现一个功能时，不关心具体的步骤，而是找一个已经具有该功能的的人或物体，通过该人或物体来实现这个功能。（强调对象）
面向对象编程(Object Oriented Programing，OOP)的本质：以类的方式组织代码，以对象的组织（封装）数据。
面向对象的三大基本特征：封装、继承和多态。
类：是一组相关属性和行为的集合，可以看成是一类事务的模板，使用事物的属性特征和行为特征来描述该类事物。
- 属性：就是该事物的状态信息。
- 行为：就是该事物能够做什么。
对象：是一类事物的具体体现，对象是类的一个实例，必然具备该类事物的属性和行为。
类与对象的关系
- 类是对一类事物的描述，是抽象的。
- 对象是一类事物的实例，是具体的。
- 类是对象的模板，对象是类的实体。
创建对象
类名 对象名 = new 类名();使用对象访问类中的成员
对象名.成员变量名; 对象名.成员方法();对象的使用格式例子:
对应到Java的类当中： 成员变量（属性）： String name; // 姓名 int age; // 年龄 成员方法（行为）： public void eat() { } // 吃饭 public void sleep() { } // 睡觉 public void study() { } // 学习 注意事项： 1. 成员变量是直接定义在类当中的，在方法外边。 2. 成员方法不要写static关键字。 */ public class Student { // 成员变量 String name; // 姓名 int age; // 姓名 // 成员方法 public void eat() { System.out.println("吃饭！"); } public void sleep() { System.out.println("睡觉！"); } public void study() { System.out.println("学习！"); } }成员变量的默认值:
![]()
面向对象程序内存图:
相关代码:
public class Student{ // 属性（描述状态），在java程序中以“成员变量”的形式存在。 // 学号 // 一个对象一份。 int no; // 这种成员变量又被称为“实例变量”。 // 姓名 String name; // 年龄 int age; // 性别 boolean sex; // 住址 String addr; }public class StudentTest{ public static void main(String[] args){ //局部变量 //错误: 可能尚未初始化变量k //访问学生姓名可以直接通过类名吗？ // 学生姓名是一个实例变量。实例变量是对象级别的变量。 // 是不是应该先有对象才能说姓名的事儿。 // 不能通过“类名”来直接访问“实例变量”。 //System.out.println(Student.name); // i属于局部变量吗？当然是。 // 局部变量存储在栈内存当中。（栈主要存储局部变量。） //int i = 100; // 创建学生对象1 // s1属于局部变量吗？当然是。 // s1这个局部变量叫做引用 Student s1 = new Student(); // 怎么访问实例变量？ // 语法：引用.实例变量名 System.out.println(s1.no); System.out.println(s1.name); System.out.println(s1.age); System.out.println(s1.sex); System.out.println(s1.addr); System.out.println("-----------------------------"); // 创建学生对象2 // s2也是局部变量。 // s2也叫做引用。 Student s2 = new Student(); System.out.println(s2.no); System.out.println(s2.name); System.out.println(s2.age); System.out.println(s2.sex); System.out.println(s2.addr); // 程序执行到此处我可以修改s1这个学生的学号吗？ // 通过“=”赋值的方式将内存中实例变量的值修改一下。 s1.no = 110; s1.name = "张三"; s1.age = 20; s1.sex = true; s1.addr = "深圳宝安区"; System.out.println("学号=" + s1.no); System.out.println("姓名=" + s1.name); System.out.println("年龄=" + s1.age); System.out.println("性别=" + s1.sex); System.out.println("住址=" + s1.addr); // 再次赋值 s1.addr = "北京大兴区"; System.out.println("住址：" + s1.addr); } public static void method(){ // i s1 s2都是main方法中的局部变量，在这里是无法访问的。 } }[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t7QDQao8-1602919367665)(C:\Users\阿旺\AppData\Roaming\Typora\typora-user-images\image-20201016210913416.png)]
总结:
（1）在类中的位置不同
成员变量：类中，方法外
局部变量：方法中或者方法声明上（形式参数）
（2）作用范围不一样
成员变量：类中
局部变量：方法中
（3）初始值不同
成员变量：有默认值
局部变量：没有默认值，必须定义，赋值，最后使用
（4）在内存中的位置不同
成员变量：堆内存
局部变量：栈内存
（5）生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失构造方法:
当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。
（无论是否自定义构造方法，所有类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。）构造方法的定义格式:
修饰符 构造方法名(参数列表){ //方法体 }public class ConstructorTest { public static void main(String[]args){ User1 u = new User1(); System.out.println(u.id);//0 //11 System.out.println(u.name);//null //lihua System.out.println(u.age);//0 //13 //这时调用的是public User1(int),所以没有手动赋值 User1 u2 = new User1(3333); System.out.println(u2.id);//0 System.out.println(u2.name);//null System.out.println(u2.age);//0 } } public class User1 { //3个属性,三个实例变量(对象变量) //用户id int id; //因为System.out.println(User1.id);错误的.需要现对象new,只要对象有了才能访问id //用户名 String name; //年龄 int age; //手动定义有参数的构造方法,无参数构造方法将自动消失. 编译会出错 //解决办法下面类注释,或者在手动写一个无参构造方法 public User1(int a){ } public User1(){ //这里实际上有三行代码,只是不看见 //无参数的构造方法体当中虽然什么代码都没有写,但是实际上是这个方法体里面 //进行的实例变量默认值初始化 //id =0 name = null age = 0;;;; //这就表示不再采用系统的默认值,手动赋值了 id = 11; name = "lihua"; age = 13; } }构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所有不需要返回值类型，甚至不需要void，使用构造方法后
总结:
1.如果你不提供构造方法，系统就会给出无参数构造方法
2.如果你提供了构造方法，系统将不再提供无参数构造方法
3.构造方法是可以重载的，即可以定义参数，也可以不定义参数封装
封装：禁止直接访问一个对象中的数据，应通过操作接口来访问。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
1.方法就是一种封装
2.关键字private也是一种封装private关键字使用格式:
private 数据类型 变量名;1.使用
private修饰成员变量
2.提供getXxx方法/setXxx方法/isXxx方法,可以访问成员变量，代码如下：代码 // 这是没有封装的Person。 // 尝试封装一下 // 不再对外暴露复杂的数据，封装起来 // 对外只提供简单的操作入口。 // 优点：第一数据安全了。第二调用者也方便了。 public class Person{ // private 表示私有的，被这个关键字修饰之后，该数据只能在本类中访问。 // 出了这个类，age属性就无法访问了。私有的。 private int age; // 每一个人年龄值不同，对象级别的属性。 // 对外提供简单的访问入口(电视机的遥控器就相当于是电视机的访问入口，简单明了。) // 外部程序只能通过调用以下的代码来完成访问 // 思考：你应该对外提供几个访问入口? // 思考：这些操作入口是否应该是方法呢？ // 写一个方法专门来完成读。(get) // 写一个方法专门来完成写。(set) // get和set方法应该带有static，还是不应该有static,get和set方法应该定义为实例方法吗？ // get读年龄，set改年龄，这个读和改都是操作的一个对象的年龄。（没有对象何来年龄） // 封装的第二步：对外提供公开的set方法和get方法作为操作入口。并且都不带static。都是实例方法。 // get方法 public int getAge(){ return age; } // set方法 public void setAge(int nianLing){ // 能不能在这个位置上设置关卡！！！！ if(nianLing < 0 || nianLing > 150){ System.out.println("对不起，年龄值不合法，请重新赋值！"); return; //直接终止程序的执行。 } //程序能够执行到这里，说明年龄一定是合法的。 age = nianLing; } } //在外部程序中访问Person这个类中的数据 public class PersonTest { public static void main(String[]args){ //创建person对象 Person p1 = new Person(); //访问年龄 //访问一个对象的属性 通常包括两种操作:一种是读数据,一种是改数据 //一 读数据 System.out.println(p1.age);//读(get 获取) //修改数据(set 表示修改/设置) p1.age = 50; System.out.println(p1.age);//再次读取 //在persontest这个外部程序中目前是可以随意对age属性进行操作的 p1.age = -100;//改(随意在这里对person的内部数据进行更改,导致业务不安全) System.out.println("您的年龄值为=" + p1.age);//读 //程序中给年龄赋值了个负数,不符合业务要求,这就是一个程序bug } } public class PersonTest2{ public static void main(String[] args){ // 创建对象 Person p1 = new Person(); // Person的age，彻底在外部不能访问了。但是这难免有点太安全了。 // age不能访问，这个程序就意义不大了。 //通过"类名."可以调用set和get方法吗? 不行 //只有方法修饰符列表中有static的时候才可以使用"类名."的方式访问 //Person.getAge();//错误: 无法从静态上下文中引用非静态 方法 getAge() //读调用getAge()方法 //第一种(不合并) //第二种(合并) System.out.println(p1.getAge()); //0 //改调用setAge()方法 p1.setAge(20);//传给nianling后再给age再给getAge System.out.println(p1.getAge()); //20 // 你折腾半天了，这不是结果还是没控制住吗？？？？？？ p1.setAge(-100); //System.out.println(p1.getAge()); // -100 System.out.println(p1.getAge()); // 20 } }总结:
封装的作用有两个：
第一个作用：保证内部结构的安全。
第二个作用：屏蔽复杂，暴露简单。
在代码级别上，封装有什么用？
一个类体当中的数据，假设封装之后，对于代码的调用人员来说，
不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了。
另外，类体中安全级别较高的数据封装起来，外部人员不能随意访问，
来保证数据的安全性。
用非静态 方法 getAge()
//读调用getAge()方法//第一种(不合并)
//第二种(合并)
System.out.println(p1.getAge()); //0//改调用setAge()方法 p1.setAge(20);//传给nianling后再给age再给getAge System.out.println(p1.getAge()); //20 // 你折腾半天了，这不是结果还是没控制住吗？？？？？？ p1.setAge(-100); //System.out.println(p1.getAge()); // -100 System.out.println(p1.getAge()); // 20}
}> 总结: > > 封装的作用有两个： > > 第一个作用：保证内部结构的安全。 > > 第二个作用：屏蔽复杂，暴露简单。 > > > > 在代码级别上，封装有什么用？ > > 一个类体当中的数据，假设封装之后，对于代码的调用人员来说， > > 不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了。 > > 另外，类体中安全级别较高的数据封装起来，外部人员不能随意访问， > > 来保证数据的安全性。
