Java自学后的前十章实时复习-cnblog

最新推荐文章于 2022-06-17 19:06:56 发布
最新推荐文章于 2022-06-17 19:06:56 发布
阅读量577 收藏 10
点赞数 6
分类专栏： 笔记 文章标签： javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47145667/article/details/109133482
版权

Java自学后的前十章练习题及实时复习

各章重点知识的总结及回顾

  1. Java执行是从 main 方法开始执行的，此方法的完整定义是 public static void main(String[]args) { }

  2. ​ Java类名的每个单词的首字母通常要求 小写 。

  3. 简述Java实现可移值性的基本原理。

    答;Java属于编译型和解释型的编程语言，所有的*.java程序必须编译为*.class文件之后才可以在电脑上执行，而执行x.class文件的电脑并不是一台真实的电脑，而是利用软件和硬件模拟出来的一台虚拟电脑，称为Java虚拟机，而针对于不同的操作系统平台，有不同版本的Java虚拟机，即：由Java虚拟机去适应不同的操作系统，即：只要Java虚拟机的支持没有改变，同一个x.class可以在不同的平台上运行

  4. 简述Java中path及classpath的作用。

    答: PATH：是操作系统的环境属性，指的是可以执行命令的程序路径；

    CLASSPATH：是所有x.class文件的执行路径，java命令执行的时候将利用此路径加载所需要的x.class文件。

  5. 详细阐述Java中使用public class或class声明一个类的区别及注意事项。

    ​ 答:使用public class定义的类，要求文件名称和类名称保持一致，在一个*.java文件之中只能存在一个public class；

    ​ 使用class定义的类，文件名称可以和类名称不一致，在一个x.java文件之中可以同时存在多个class定义，编译之后 会产生多个x.class文件。

  6. 请解释“&”和“&&”的区别？

    答:&在进行逻辑运算时表示所有判断条件都需要判断，而“&&”为短路与，在前面的判断返回false时后面判断将不再执行，最终的结果就是false。

    ​ &还可以应用在位操作上。

    请解释“|”和“||”的区别？

    答:|在进行逻辑运算时表示所有判断条件都需要判断，而“|”为短路或，在前面的判断返回true时后面判断将不再执行，最终的结果就是true。

    ​ |还可以应用在位操作上。

  7. 基本数据类型不牵扯到内存开辟的问题,而引用数据则关系到内存

  8. 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。

  9. 数据类型转换

    范围小的数据类型可以自动转为范围大的数据类型,而范围大的到小的则需要强行转换

  10. Java中一些命名规范:*类名的命名要遵循首字母大写原则，类的名字必须由大写字母开头而单词中的其他字母均为小写；如果一个类名称是由多个单词组成，则每个单词的首字母均应为大写例如ModelWhAction；如果类名称中包含单词缩写，则这个所写词的每个字母均应大写，如：XMLExample,还有一点命名技巧就是由于类是设计用来代表对象的，所以在命名类时应尽量选择名词　 变量的命名要遵循通俗易懂的原则，比如名字就用 name ，而不是用a、b、c这样的命名。变量命名除了变量名外，实例，包括类、类常量，均采用大小写混合的方式，第一个单词的首字母小写，其后单词的首字母大写。变量名不应以下划线或美元符号开头，尽管这在语法上是允许的。但是在工作中这样做会降低代码的可阅读性，在工作上这是不规范的.使用驼峰命名法命名多个单词组成的变量名。

方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头。

需要用到的变量命名和方法命名要遵循首字母小写原则，如果名称是由多个单词组成，每个单词的首字母都要大写（除首个单词）。

所有命名规则必须遵循以下规则：
 1)、名称只能由字母、数字、下划线、$符号组成

 2)、命名时不能以数字开头

 3)、在命名是绝对不能出现Java关键字。

  1. 方法重载:方法名称相同,参数类型或者个数不同, 判断: 定义多个同命方法时,可以依靠返回值区别同名方法(x) 2 在进行方法重载时返回值类型必须相同,否则无法通过程序的编译.(x)

  2. 方法递归调用是指:本方法自身重复执行,在使用递归调用时一定设置好方法的结束条件,否则会出现内存溢出问题,造成程序的中断.

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()😗
    1. 一定要读取到有效字符后才会结束输入
  1. 对输入的有效字符之前遇到的空白，next()方法会自动将其去掉
  2. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
  3. 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();
	  }
	}
}
image-20201017115334357

Java面向对象的编程

对象的创建

面向过程：当需要实现一个功能时，每个具体的步骤都要亲力亲为，详细处理每个细节。（强调过程）

面向对象：当需要实现一个功能时，不关心具体的步骤，而是找一个已经具有该功能的的人或物体，通过该人或物体来实现这个功能。（强调对象）

面向对象编程(Object Oriented Programing，OOP)的本质：以类的方式组织代码，以对象的组织（封装）数据。

面向对象的三大基本特征：封装、继承和多态。

类：是一组相关属性和行为的集合，可以看成是一类事务的模板，使用事物的属性特征和行为特征来描述该类事物。

  1. 属性：就是该事物的状态信息。
  2. 行为：就是该事物能够做什么。

对象：是一类事物的具体体现，对象是类的一个实例，必然具备该类事物的属性和行为。

类与对象的关系

  1. 类是对一类事物的描述，是抽象的。
  2. 对象是一类事物的实例，是具体的。
  3. 类是对象的模板，对象是类的实体。

创建对象

类名 对象名 = 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("学习！");
    }

}

成员变量的默认值:

20200612010238392

面向对象程序内存图:

相关代码:

/*
学生类
	学号：int
	姓名：String
	年龄：int
	性别：boolean
	住址：String

变量必须先声明，再赋值才能访问。

注意：对于成员变量来说，没有手动赋值时，系统默认赋值。
赋的值都是默认值，那么默认值是什么？

类型				默认值
---------------------
byte				0
short				0
int				0
long				0L
float				0.0F
double			0.0
boolean			false
char				\u0000
引用数据类型	null

null是一个java关键字，全部小写，表示空。是引用类型的默认值。

分析：对于成员变量来说，是不是应该一个对象有一份。
	李四有李四的学号
	张三有张三的学号
	李四和张三的学号不一样。所以应该有两块不同的内存空间。

*/
public class Student{

	// 属性（描述状态），在java程序中以“成员变量”的形式存在。

	// 学号
	// 一个对象一份。
	int no; // 这种成员变量又被称为“实例变量”。

	// 姓名
	String name;

	// 年龄
	int age;

	// 性别
	boolean sex;

	// 住址
	String addr;

}


/*
	对象的创建和使用。
*/
public class StudentTest{

	public static void main(String[] args){

		//局部变量
		//错误: 可能尚未初始化变量k
		/*
		int k;
		System.out.println(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方法中的局部变量，在这里是无法访问的。
		/*
		System.out.println(i);
		System.out.println(s1);
		System.out.println(s2);
		*/
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t7QDQao8-1602919367665)(C:\Users\阿旺\AppData\Roaming\Typora\typora-user-images\image-20201016210913416.png)]

总结:

（1）在类中的位置不同
成员变量：类中，方法外
局部变量：方法中或者方法声明上（形式参数）
（2）作用范围不一样
成员变量：类中
局部变量：方法中
（3）初始值不同
成员变量：有默认值
局部变量：没有默认值，必须定义，赋值，最后使用
（4）在内存中的位置不同
成员变量：堆内存
局部变量：栈内存
（5）生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

构造方法:

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。
（无论是否自定义构造方法，所有类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。）

构造方法的定义格式:

修饰符 构造方法名(参数列表){
	//方法体
}

/*
  1 构造方法(Constructor)
  2 构造方法的作用:
      创建对象,并且创建对象的过程中给属性赋值(初始化)
*/
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
	}
}

/*
  1 id  name  age 都有默认值
  0    null  0
  
  2 思考:实力变量没有手动赋值的时候,系统会默认会赋值
  那么这个默认赋值操作是在什么时候进行的?
       是在类加载的时候给这些实例变量赋值的吗还是等对象创建的时候赋值的?
             :::不是,实例变量是在构造方法执行的过程中完成初始化的,完成赋值的	 
			 */
	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表示人类：
		每一个人都有年龄这样的属性。
		年龄age，int类型。
	
	我这里先不使用封装机制，分析程序存在什么缺点？
		Person类的age属性对外暴露，可以在外部程序中随意访问，导致了不安全。
	
	怎么解决这个问题？
		封装。
*/

// 这是没有封装的Person。
/*
public class Person{

	// 实例变量(属性)
	int age; //age属性是暴露的，在外部程序中可以随意访问。导致了不安全。

}
*/

// 尝试封装一下
// 不再对外暴露复杂的数据，封装起来
// 对外只提供简单的操作入口。
// 优点：第一数据安全了。第二调用者也方便了。
public class Person{
	// private 表示私有的，被这个关键字修饰之后，该数据只能在本类中访问。
	// 出了这个类，age属性就无法访问了。私有的。
	private int age; // 每一个人年龄值不同，对象级别的属性。

	// 对外提供简单的访问入口(电视机的遥控器就相当于是电视机的访问入口，简单明了。)
	// 外部程序只能通过调用以下的代码来完成访问
	// 思考：你应该对外提供几个访问入口?
	// 思考：这些操作入口是否应该是方法呢？
	// 写一个方法专门来完成读。(get)
	// 写一个方法专门来完成写。(set)
	// get和set方法应该带有static，还是不应该有static,get和set方法应该定义为实例方法吗？
	// get读年龄，set改年龄，这个读和改都是操作的一个对象的年龄。（没有对象何来年龄）
	// 封装的第二步：对外提供公开的set方法和get方法作为操作入口。并且都不带static。都是实例方法。
	/*
		[修饰符列表] 返回值类型 方法名(形式参数列表){
		}

		注意：
			java开发规范中有要求，set方法和get方法要满足以下格式。
				get方法的要求：
					public 返回值类型 get+属性名首字母大写(无参){
						return xxx;
					}
				set方法的要求：
					public void set+属性名首字母大写(有1个参数){
						xxx = 参数;
					}
			
			大家尽量按照java规范中要求的格式提供set和get方法。
			如果不按照这个规范格式来，那么你的程序将不是一个通用的程序。

	*/
	// 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不能访问，这个程序就意义不大了。
		
		/*
		// 读age属性的值
		System.out.println(p1.age);
		 
		 错误: age 在 Person 中是 private 访问控制
                System.out.println(p1.age);
				

		// 修改age属性的值
		p1.age = 20;

		// 读age
		System.out.println(p1.age);
		*/
		
   //通过"类名."可以调用set和get方法吗?  不行
   //只有方法修饰符列表中有static的时候才可以使用"类名."的方式访问
   //Person.getAge();//错误: 无法从静态上下文中引用非静态 方法 getAge()


      //读调用getAge()方法
	  //第一种(不合并)
     /*int nianLing = p1.getAge();
        System.out.println(nianLing);//0
		*/
		//第二种(合并)
	   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()方法

//第一种(不合并)
/*int nianLing = p1.getAge();
System.out.println(nianLing);//0
*/
//第二种(合并)
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

}
}


> 总结:
>
> 封装的作用有两个：
>
> 第一个作用：保证内部结构的安全。
>
> 第二个作用：屏蔽复杂，暴露简单。
>
>  
>
> 在代码级别上，封装有什么用？
>
> 一个类体当中的数据，假设封装之后，对于代码的调用人员来说，
>
> 不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了。
>
> 另外，类体中安全级别较高的数据封装起来，外部人员不能随意访问，
>
> 来保证数据的安全性。
DANboyབོད་
关注
  • 6
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
Xamarin-Android-CNBlog
12-16
【Xamarin-Android-CNBlog】项目是一个专注于Xamarin平台下的Android开发资源集合，它为中国开发者提供了丰富的中文教程、示例代码和实践经验。Xamarin是一种跨平台的移动开发框架，允许开发者使用C#语言和.NET ...
手写mybatis单表查询实现-cnblog.md
06-09
手写实现mybatis，mybatis处理流程图，mybatis实现需要的几个函数，各个函数的调用。
Java必知习题
m0_60786924的博客
06-17 2478
1、 Java源程序文件的后缀是 *.java ，Java字节码文件的后缀名称是 *.class 。2、 Java程序实现可移值性，依靠的是 JVM 。3、 Java语言的三个分支是： JAVA SE 、 JAVA ME 、 JAVA EE 。4、 Java程序由 类 组成，如果Java使用 public class 声明类，则文件名称必须与类名称一致。5、 Java执行是从 main() 方法开始执行的，此方法的完整定
java之public class和class声明区别详解 （转）
weixin_34209851的博客
08-15 240
在编写类的时候可以使用两种方式定义类： public class定义类: class定义类: 如果一个类声明的时候使用了public class进行了声明，则类名称必须与文件名称完全一致。范例：定义一个类(文件名称为：Hello.java)public class HelloDemo{ //声明一个类，类名称的命名规范：所有单词的首字母大写 public static...
JAVA中类的public class与class的区别详解
热门推荐
区块链之美
05-10 6万+
1.类的访问权限 为了控制某个类的访问权限，修饰词必须出现在关键字class之前。例如：public class Student {} 在编写类的时候可以使用两种方式定义类： （A）public class定义类 （B）class定义类 2.public class定义类 如果一个类声明的时候使用了public class进行了声明，则类名称必须与文件名称完全一致。 被publ...
java基础(4)public class 和class的区别及注意事项
见贤思齐焉，见不贤内自省
11-28 4395
java基础(4)public class 和class的区别及注意事项
class 与 public class的区别
tangcc的博客
12-08 727
1.public class 类名 与 文件名一致，且所有包都能访问 2.class 类名与文件名不一定要一致，但只能是同包中才能访问
CnBlog:cnblog.com的RSS
05-20
【压缩包子文件的文件名称列表】"CnBlog-master"可能意味着这个压缩包包含了一个名为"CnBlog-master"的主文件或项目，这通常与Git仓库中的主分支对应，用于存放整个项目的源代码或数据。在本例中，可能是用来管理和...
CNBlog.rar_CNBLOG@DLHC-TECH_cbnlog_cnblog_http://www.cnblo_juwan
09-20
博客园（CNBlog）是知名的中文开发者社区，它提供了丰富的技术文章、个人博客、讨论论坛以及各种编程资源。"CNBlog.rar" 是一个压缩文件，其中包含了与博客园相关的数据，可能包括博客文章、用户配置、离线阅读资料...
cnblog-theme-simpcode:一款简单干净的博客园主题
05-23
cnblog-theme-simpcode 一款简单干净的博客园主题，示例博客： 一、准备 在开始之前，必须要确保你已经申请了博客园 JS 权限，具体申请过程就不详细介绍了，读者自行网上搜索，很简单的。 本皮肤如果经常逛博客的...
Java web 写的第一个博客
06-06
Java web 写的第一个博客，供大家一起共同分享学习。
Java编程中public class与class的区别（Public类和类的区别）
天射手座的博客
01-03 2万+
Public class: 1 如果使用了该类，则类名必须与文件名一致 2 被public修饰的类可以被其他包访问 Class: Class类可以访问其他Public类，但不能被其他包访问 Conclusion 每个文件中只能有一个Public类，可以理解为main部分 ...
第1章：Java简介 习题
犟驴的博客
06-10 1550
一、填空题1、    Java源程序文件的后缀是   *.java     ，Java字节码文件的后缀名称是   *.class    。2、    Java程序实现可移值性，依靠的是    JVM    。3、    Java语言的三个分支是：   JAVA SE    、   JAVA ME  、  JAVA EE   。4、    Java程序由   类    组成，如果Java使用  pu...
关于public class 和 class声明类的区别
weixin_30918633的博客
11-01 142
public class如果一个类声明的时候使用了publicclass进行了声明，则类名称必须与文件名称完全一致。 class 声明一个类，类名称可以与文件名不一致，但是会生成*.class. public class定义的类是什么地方都可以访问，而只是class的类，是包级私有，就是同一个包里才可以访问。一个文件里面只能有一个类声明为public class，而且...
简单java程序-public class 与class 声明类的区别
xiaoliang_xie的专栏
11-28 546
使用"public class" 声明一个类，类名称必须与文件名称一致，否则程序将无法编译 使用"class" 声明一个类，类名称与文件名可以不一致，但是执行的时候一定要执行生成后的*.class.  在一个java文件中可以有多个class类的定义，但是只能有一个public class定义
使用 React 和 Redux 进行井字游戏并附带源代码.zip
最新发布
07-24
项目：使用 React 和 Redux 进行井字游戏并附带源代码 使用 react 和 redux 的井字游戏是一个简单的 react 项目。整个项目都是使用 react components 和redux制作的。游戏很简单，玩法也很多。要运行此项目，您必须先安装 NodeJS。 关于项目 井字游戏反应而 redux 是使用ReactJS开发的。说到这个游戏，它具有高级功能和游戏玩法。要运行此项目，首先，您必须安装费用到您的系统。然后运行npm安装然后开始运行npm开始。游戏启动后，您可以选择不同的游戏选项。您还可以选择所需的网格框数量。此外，您还可以选择对手的类型。 要运行此项目，您需要 在计算机上安装NodeJS 并使用现代浏览器，例如 Google Chrome、  Mozilla Firefox。 演示： 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
使用 JavaScript 编写的专注力游戏（附源代码）.zip
07-24
项目：JavaScript 中的专注力游戏（附源代码） 专注力游戏是一个使用 JavaScript、CSS 和 HTML 开发的简单项目。这款游戏很有趣。玩家必须点击移动的框并获得分数。要点击正确的位置，玩家需要在这个游戏中集中注意力。这款游戏可以帮助玩家练习以进一步增强他们的专注力。 游戏制作 这个游戏项目仅使用 HTML、CSS 和 JavaScript。说到这个游戏的特点，用户必须单击移动框并得分。游戏有三种模式：简单、中等和困难。游戏的 PC 控制非常简单。您只需使用光标单击移动框的碎片即可。 该游戏包含大量的 javascript 以确保游戏正常运行。 如何运行该项目？ 要运行此游戏，您不需要任何类型的本地服务器，但需要浏览器。我们建议您使用现代浏览器，如 Google Chrome 和 Mozilla Firefox。要玩游戏，首先，单击 index.html 文件在浏览器中打开游戏。 演示： 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
人脸识别方案资料61EDA-C1590.zip
07-24
人脸识别方案资料61EDA_C1590.zip
316、基于DK124设计的离线式开关电源设计12V 2A（原理图、PCB图、BOM表、设计说明）
07-24
316、基于DK124设计的离线式开关电源设计12V 2A（原理图、PCB图、BOM表、设计说明） 该设计为DK124控制的开关电源，实现12V 2A输出； 功能： 1、使用DK124核心控制； 2、反激式开关电源拓扑设计； 3、实现12V 2A输出； 4、市电输入； 5、整流、滤波、变压器等电路； 6、原理图、PCB图、BOM表、设计说明；
CloudFoundry开源PaaS平台上的JAVA应用开发指南
"在cloud-foundry上开发JAVA应用.docx" Cloud Foundry 是一个开源的 Platform-as-a-Service (PaaS) 平台，专为开发者设计，让他们能够在各种云平台上自由选择开发框架和应用服务。VMware 创立了这个项目，并且获得...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值