java的Criterion的andTdzGreaterThan java中answer

转载

mob64ca13f53d41 2024-01-12 08:53:56

文章标签 java 数组 System 数据类型 文章分类 Java 后端开发

JAVA学习—基础知识

文章目录

1.常量
2.变量
3.运算符
4.Scanner 键盘输入
5.流程
6.Eclipse基础知识
7.数组
8.JAVA 内存分配
9.方法的定义、调用
10.方法的重载、参数传递
11.面向对象
12.成员变量与局部变量
13.private关键字
14.this 关键字
15.构造方法
16.定义标准的POJO类
17.字符串的重新认识（字符串池）
更新中...

1.常量

关于程序注释

单行注释：以//开始，直到本行结束
多行注释：以/*开始，以*/ 结束，中间内容都属于注释
文档注释：以/**开始，以*/结束，中间内容都属于注释

关于程序当中的常量

1.字符串常量：凡是用双引号引起来的内容。
2.整数常量：例如1000、-250。
3.浮点常量：例如3.14。
4.字符常量：凡是用单引号引起来的单个字符，只能有一个字符。
5.布尔常量：只有两种取值，true、false。
6.空常量：null。

2.变量

JAVA中的数据类型

基础类型8种：byte、short、int、long、float、double、char、boolean

引用类型：除了基本类型都算，包括数组、类、接口、字符串等

java的Criterion的andTdzGreaterThan java中answer_数据类型

注意：定义一个long数据时，要在后加L；定义float数据时，后加F。

变量的作用域：变量定义在哪个大括号内就只能在哪引用，超出就不能。

可以同时定义多个类型相同的变量。如：int a,b,c; 或者 int a=1, b=2, c=3;

3.运算符

四则运算符
+号对于字符串来说不是相加的意思而是连接的功能；任何数据类型与字符串类型相连，结果都是字符串。
自增运算符：++ 自减运算符： --，可以使用在变量前面或者后面，当单独使用时，没有什么区别；混合使用的时候，有很大区别，前加加则是先加后用，后加加则是先用后加。只能用于变量不能用于常量。

赋值预算符
复合赋值运算符+=、-=、*=、/=、%= 这些，赋值运算符左边只能是一个变量，右边无所谓。

比较运算符<、>、<=、>=、==、!= 这些，==两个等号连写才是相等的意思。比较预算符的结果一定是一个boolean指，成立true，错误false。

逻辑运算符

与& 或| 亦或^ 非！ 与& 全是true才是true；否则就是false

或| 至少一个true就是true；全是false才是false

亦或^ 相同就是false；不同才是true

非！ 本来是true变成false；本来是false变成true

java的Criterion的andTdzGreaterThan java中answer_数据类型_02

短路使用

短路与 &&

短路或 ||

如果表达式左边已经可以确定最终结果，那么右边的代码将不再执行，提高程序效率。所以凡是遇到与、或这两个逻辑运算符时，都推荐双写，且只有与‘、或能双写，其他不能。

4.Scanner 键盘输入

1.导包：在public class 之前写一行代码：import 包路径名 2.创建：数据类型变量名 = new 数据类型（） 3.使用：变量名称.方法名（）

使用scanner

import java.util.Scanner;
Scanner sc = new Scannner(System.in);//System.in 代表从键盘输入
1.获取int数字： int num = sc.nextInt();
2.获取字符串： String str = sc.next();

5.流程

流程是指程序步骤执行的先后顺序，先做什么，后做什么。
可以分类为1.顺序结构；2.选择结构；3.循环结构
1.顺序结构

先写的先执行，后写的后执行

2.选择结构

主要通过if语句来实现
单if语句，执行某些步骤，或者不执行
标准的if-else语句，在两种方案中选择一种执行
扩展的if-else语句，在3套方案执行一种执行

3.循环结构
for循环

一个典型的for循环结构的组成部分有：
初始化语句，这部分最先执行，且只执行一次
条件判断（boolean结果），如果成立循环继续，如果不成立退出循环
循环体，每次重复执行循环体的代码
步进语句，每次循环体执行后，都会执行一次步进语句

while循环

条件判断，满足循环条件则循环，不满足则跳出循环
执行具体的语句

扩展格式

初始化语句，完成循环变量初始化
循环体，判断是否满足循环条件，不满足则跳出循环
执行具体的语句
步进语句，循环条件所涉及变量的变化情况

for与while的区别

大多时候，for循环可以和while循环等效替换，但是有几点差别
for循环格式固定，控制次数更方便，而while格式更灵活，不太在意循环次数。所以次数确定时用for多，次数不确定，使用while多。
for循环小括号内定义的变量，仅循环内可用，while循环的初始化表达式本来就在外面，仍可以用。
跳转语句continue的效果不同。

跳转控制语句

break：一旦执行，整个循环立刻结束
continue：一旦执行，当前循环剩余内容立刻跳过，开始下一次循环

循环嵌套

以打印一天中的所有分钟时刻，外层控制小时，内层控制分钟为例。
如果在循环嵌套中使用跳转控制语句，那么只能跳出当前层。

package test1;
/**
 * 
 * @author hengyuzuo
 *
 */
public class TestDemo4 {
	
	public static void main(String[] args) {
		for(int i = 0; i <= 23; i++) {
			for(int j = 1; j <= 60; j++) {
				System.out.println("这是" + i + "小时" + j + "分钟");
			}// Of for j
		}// Of for i
	}// Of main

}// Of class TestDemo4

如果内层的跳转控制语句想要跳出外层，就要增加标签，标签就是一个自定义的标识符。

格式：

标签名称：for（;;){
	for(;;){
		break 标签名称;
	}
}

猜猜下面代码的count次数是多少？

package test1;
/**
 * 
 * @author hengyuzuo
 *
 */
public class TestDemo5 {
	
	public static void main(String[] args) {
		int count = 0;
		label:for(int i = 1; i <= 10; i++) {
			for(int j = 1; j <= 5; j++) {
				
				if(j == 3) {
					break label;
				}// Of if
				count ++;
			}// Of for j
		}// Of for i
		System.out.println( count );
	}// Of main

}// Of class TestDemo5

次数为2

6.Eclipse基础知识

eclipse里的文档从大到小为，workspace——java project——src——包package——类class
在建立package时，如it.test.demo1，实际上是建立了一个it文件夹里面包含test文件夹里面包含demo1；
在文档里src是存放.java文件的，bin是存放.class文件的

关于程序注释

单行注释：以//开始，直到本行结束
多行注释：以/*开始，以*/ 结束，中间内容都属于注释
文档注释：以/**开始，以*/结束，中间内容都属于注释

快捷键

删除当前行：ctrl + D
格式化: ctrl + shift + f (自动将格式对齐)
向上移动代码：alt +向上
向下移动代码：alt +向下
向上复制一行：ctrl + alt +向上
向下复制一行：ctrl + alt +向下
智能提示： alt + /
添加单行注释： ctrl + / 取消： ctrl +
添加多行注释： ctrl + shift + / 取消： ctrl + shift + \
特别是只能提示，如果想打public static void main(String[] args)，只需要打main，然后alt + /
如果想打System.out.println("")，只需要打syso 然后alt + /

7.数组

数组是一种引用类型，变量只能存放一个数据，数组可以存放多个类型统一的数据

定义一个数组

数据类型 [] 数组名称；

数组定义好了后，要想使用一定要初始化！

初始化方法有两种：
动态初始化，指定数组的长度 数据类型[] 数组名称 = new 数据类型[数组长度]
静态初始化，指定数组的内容数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，...} 也可以分开写

package test1;
/**
 * 
 * @author hengyuzuo
 *
 */
public class TestDemo6 {
	
	public static void main(String[] args) {
		int[] array1 = new int[3];
		/**
		 * 动态初始化一个数组，名字为array
		 * 数组中所有的元素都是int类型
		 * 数组中可以存放三个元素
		 */
		
		String[] array2 = new String[10];
		//定义一个数组，存放10个字符串类型的元素
		
	}// Of main
}// Of class TestDemo6

访问/改变数组中的元素

如果直接打印数组的名称，那么结果是16进制的地址值（哈希值）
正确访问格式为：数组名称 [索引] 索引：也就是数组中多个元素的编号，是从0开始，一直到长度减一为止
动态初始化的时候，数组中的元素都会被赋予一个默认值
如果是整数，默认是0
如果是浮点数，默认是0.0
如果是字符，默认是\u0000（unicode写法）
如果是布尔值，默认是false
如果是字符串或其他引用类型，默认是null

动态初始化，静态初始化的例子
静态初始化有标准格式和简便格式，其中简便格式不能分成两步写

package test1;
/**
 * 
 * @author hengyuzuo
 *
 */
public class TestDemo6 {
	
	public static void main(String[] args) {
		int[] array1 = new int[3];
		/**
		 * 动态初始化一个数组，名字为array
		 * 数组中所有的元素都是int类型
		 * 数组中可以存放三个元素
		 * 三个元素分别赋值、输出
		 */
		array1[0] = 10;
		array1[1] = 20;
		array1[2] = 30;
		System.out.println(array1[0]);
		System.out.println(array1[1]);
		System.out.println(array1[2]);
		
		//静态初始化,只要一个步骤
		int[] array2 = new int[] {15,25,35};
		System.out.println(array2[0]);
		System.out.println(array2[1]);
		System.out.println(array2[2]);
		
		//静态初始化的简便写法，不能拆成两步
		int[] array3 = {10,20,30};
		System.out.println(array3[0]);
		System.out.println(array3[1]);
		System.out.println(array3[2]);		
				
	}// Of main
}// Of class TestDemo6

获取数组的长度

格式：数组名称.length
将会得到一个int数字，代表数组的长度
【注意】一个数组一旦在内存中创建了，那么数组的长度是不能发生改变的！

数组练习
1.求数组中的最大值

package test1;
/**
 * 
 * @author hengyuzuo
 *
 */
public class TestDemo7 {
	
	public static void main(String[] args) {
		
		int[] array1 = {1,2,3,4,5};
		//静态初始化要比较的数组
		int max = array1[0];
		
		//循环比较大小
		for(int i = 0; i < array1.length; i++) {
			if(array1[i] >= max) {
				max = array1[i];
			}// Of if
		}// Of for i
		
		System.out.println("最大值为: " + max);;
	}// Of main

}// Of class TestDemo7

8.JAVA 内存分配

程序运行时会申请内存，内存会分为5个部分
栈（stack）：主要用来存放局部变量
堆（heap）：凡是new出来的东西，都在堆当中
方法区（method area）：存放与.class 相关的东西
本地方法区（native method area）：与操作系统有关
寄存器（pc register）：与CPU有关，性能极高

对于数组的初始化可以用以下图来理解

java的Criterion的andTdzGreaterThan java中answer_System_03

栈里面用来存放局部变量，所以当直接打印数组名称时，结果是一个16进制的地址值；

当赋值时，变量通过查找栈中的地址值，来修改堆中的数据

java的Criterion的andTdzGreaterThan java中answer_数组_04

如果将数组长度改为5，其实是新建了一个地址，对应5个数，而老数组长度依旧是3，新数组长度为5，

这就应证了上面的一句话：【注意】一个数组一旦在内存中创建了，那么数组的长度是不能发生改变的！

9.方法的定义、调用

类似于其他语言的function，使用代码的时候，直接调用就行
定义一个方法的格式：

修饰符 返回值类型 方法名称（参数类型 参数名称）
	方法体
	return 返回值；

java的Criterion的andTdzGreaterThan java中answer_数组_05

比如定义一个加法的method

package test2;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Test2Demo1 {
	
	public static void main(String[] args) {
		
	}// Of main
	
	/**
	 * 定义一个最简单的加法 method
	 * @param paraNum1
	 * @param paraNum2
	 * @return
	 */
	public static int sum(int paraNum1, int paraNum2) {

		int result = paraNum1 + paraNum2;
		
		return result;
	}// Of sum

}// Of class Test2Demo1

【注意】：
1.多个方法之间的定义没有前后关系
2.不能在一个方法的内部嵌套定义另一个方法
3.方法定义之后，不会执行，如果想要执行，一定要调用

怎样调用方法
单独调用，格式：方法名称（参数值）在单独调用的时候，无法使用方法的返回值
打印调用，格式：System.out.println(方法名称（参数值）)调用方法，并将返回值打印出来
赋值调用，格式：数据类型变量名称 = 方法名称（参数指）调用方法，并将返回值交给一个变量，变量的数据类型必须和方法的返回值类型对应

package test2;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Test2Demo1 {
	
	public static void main(String[] args) {
		
		//单独调用
		sum(110,220);
		
		//打印调用
		System.out.println(sum(11,22));
		
		//赋值调用
		int tempNum = sum(15,25);
		System.out.println(tempNum);
	}// Of main
	
	/**
	 * 定义一个最简单的加法 method
	 * @param paraNum1
	 * @param paraNum2
	 * @return
	 */
	public static int sum(int paraNum1, int paraNum2) {

		int result = paraNum1 + paraNum2;
		
		return result;
	}// Of sum

}// Of class Test2Demo1

方法与变量的名称

变量的名称可以和方法的名称一样
不同的方法里可以有相同的变量名，因为属于不同的括号

练习：键盘输入两个数字，定义一个方法，求出最大值

package test2;
import java.util.Scanner;

/**
 * 
 * @author hengyuzuo
 *
 */
public class Test2Demo2 {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
	
		System.out.println("请输入第一个数字： ");
		int tempNum1 = sc.nextInt();
		
		System.out.println("请输入第二个数字： ");
		int tempNum2 = sc.nextInt();
		
		//打印调用方法max
		System.out.println("最大值为：" + max(tempNum1, tempNum2));

	}// Of main
	
	/**
	 * max
	 * @param paraNum1
	 * @param paraNum2
	 * @return max
	 */
	public static int max(int paraNum1, int paraNum2) {
		int max = paraNum1;
		if(max < paraNum2) {
			max = paraNum2;
		}// Of if
		return max;
	}// Of max

}// Of class Test2Demo2

运行结果

请输入第一个数字： 
500
请输入第二个数字： 
465
最大值为：500

方法的有返回值与无返回值

流程如下

java的Criterion的andTdzGreaterThan java中answer_数据类型_06

如果一个方法只是执行一些操作，没有最终的数据交还给调用处，则该方法是没有返回值的方法。需要使用一个关键字：void。

返回值没有，并不代表不能有参数，参数与返回值并没有必然联系
对于void来说，不能return一个具体的返回值
对于void来说，可以不写return
【重要】对于没有返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用

练习：遍历数组

package test2;

/**
 * 
 * @author hengyuzuo
 *
 */
public class Test2Demo3 {
	
	public static void main(String[] args) {
		//静态初始化数组
		int[] array = {1,2,3,4,5,6};
		
		//调用方法
		printArray(array);
	}// Of main
	
	public static void printArray(int[] array) {
		for(int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}// Of for i
		
	}// Of printArray 

}// Of printArray

10.方法的重载、参数传递

对于类似功能的多个方法，只需要记住一个相同的方法名即可，可以根据参数列表的不同自动适配，使用方法重载（overload）技术
使用方法重载（overload）：方法的名称相同，但是参数列表不同

注意事项：
何为参数列表不同？
1.参数的个数不同
2.参数的类型不同
3.参数的多类型顺序不同
4.重载与返回值类型不同无关
5.与参数的名称无关

参数传递
形式参数：在定义方法的时候，写在小括号类的参数
实际参数：在调用方法的时候，真正传入方法里的数据
对于基本数据类型包括String来说，形参的操作不会影响实际参数
对于引用数据类型除了String来说，形参的操作会影响实际参数

对于基本数据类型包括String来说，形参不会改变实参，例子如下

package test2;

/**
 * 
 * @author hengyuzuo
 *
 */
public class Test2Demo4 {
	
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		
		change(a,b);
		
		System.out.println( a );
		System.out.println( b );
	}// Of main
	
	/**
	 * method:Expand tenfold
	 * @param a
	 * @param b
	 */
	public static void change(int a, int b) {
		a *= 10;
		b *= 10;
	}// Of change

}// Of class Test2Demo2

a，b 形参都被扩大十倍，但是实参任然是原数

对于引用数据类型除了String来说，形参的操作会影响实际参数，例子如下

package test2;

/**
 * 
 * @author hengyuzuo
 *
 */
public class Test2Demo5 {
	
	public static void main(String[] args) {
		
		//静态初始化数组
		int[] array = {1,2,3};
		
		change(array);
		
		System.out.println(array[0]);
		System.out.println(array[1]);
		System.out.println(array[2]);
	}// Of main
	
	public static void change(int[] array) {
		for (int i = 0; i < array.length; i++) {
			array[i] *= 10;
		}// Of for i 
		
	}// Of change
}// Of class Test2Demo5

此时，实参跟形参一起变大了10倍

11.面向对象

面向过程：当需要实现一个功能的时候，看中的是每一个步骤是怎么实现的，整体的过程是什么样的，每一个操作都要亲历亲为
面向对象：当需要实现一个功能的时候，不看重具体的过程和步骤，而关心谁能帮我做这个事
举例
吃饭—面向过程（自己做）：饿了、买菜、洗菜、切菜、炒菜、盛菜、吃菜
吃饭—面向对象（出去吃）：饿了、买菜、吃菜
面向对象有三大特征：封装性、继承性、多态性

类与对象

java的Criterion的andTdzGreaterThan java中answer_System_07

一直写的 public class 就是一个类。

类就是图纸，根据图纸来创造手机，根据类创造对象

类的定义
类包含两部分：成员变量和成员方法
1.成员变量，将变量位置直接定义在类中，在方法外，即为成员变量。
2.成员方法，将普通的方法去掉 static 关键字，即为成员方法。

列子
以学生为一个列子，那么学生的属性有年龄和姓名（只列举两项）。行为可以有吃饭和睡觉。对应起来
成员变量就是：String name;//姓名 int age;//年龄 成员方法就是：public void eat(){...} public void sleep(){...}

package a21;
/**
 * 
 * @author hengyuzuo
 *
 */
public class StudentDemo {
	
	//成员变量
	String name;
	int age;
	
	//成员方法
	public void eat() {
		System.out.println("干饭！");
	}// Of eat
	
	public void sleep() {
		System.out.println("睡觉！");
	}// Of sleep
}// Of StudentDome

类无法使用，要想使用，则根据类来创建一个对象
写法：类名称对象名 = new 类名称（）；

package a21;
/**
 * 
 * @author hengyuzuo
 *
 */
public class StudentDemo1 {

	public static void main(String[] args) {
		StudentDemo stu1 = new StudentDemo();//创建了一个对象
		StudentDemo stu2 = new StudentDemo();//创建了第二个对象
		
	}// Of main

}// Of class StudentDemo1

如何使用对象
类包含成员变量和成员方法，类所创建的对象也有这两个部分。
如果对成员变量没有赋值，会有一个默认值
用法：对象名.成员变量名 对象名.成员方法名（参数）; 参数看需要写

package a21;
/**
 * 
 * @author hengyuzuo
 *
 */
public class StudentDemo3 {
	
	public static void mian(String[] args) {
		// TODO Auto-generated method stub
		StudentDemo stu = new StudentDemo();//创建一个学生对象
		
		//改变成员变量的数值
		stu.name = "金龙";
		stu.age = 24;
		System.out.println(stu.name);
		System.out.println(stu.age);
		
		//使用对象当中的成员方法
		stu.eat();//调用吃饭的成员方法
		stu.sleep();//调用睡觉的成员方法
	}// Of main
}// Of class StudentDemo3

12.成员变量与局部变量

不同点：
1.定义的位置不同
局部变量：定义在方法内部（成员方法的变量也是局部变量）
成员变量：直接定义在类当中，在方法的外面
2.内存中的位置不一样
局部变量：在栈内存中，stack
成员变量：在堆当中，heap
3.生命周期不一样
局部变量：随着方法的进栈而出现，随着方法的出栈而消失
成员变量：随着对象被创建而出现，随着对象被JVM回收而消失
4.默认值不一样
局部变量：没有默认值，必须赋值后才能使用
成员变量：如果没有赋值，那么会有一个默认值

13.private关键字

举例
创建一个类

package test3;

/**
 * 
 * @author hengyuzuo
 *
 */
public class Person {
	
	//成员变量
	String name;
	int age;
	
	//成员方法
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("my name is: " + name +". my age is: " + age);
	}// Of show

}// Of class person

然后调用（在同一个包类内就不用导包）

package test3;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Person2 {
	
	public static void main(String[] args) {
		
		//创建对象
		Person pe = new Person();
		
		//成员变量赋值
		pe.name = "jing long";
		pe.age = 18;
		
		//调用成员方法
		pe.show();	
	}// Of main

}// Of class Person2

运行结果是my name is: jing long. my age is: 18 但是我们都知道年龄有一定的范围，所以使用private关键字来修饰

一旦使用private关键字，那么超过本类的范围就无法直接访问，但是可以间接访问

为这个成员变量编写一对： Setter Getter 方法

Setter Getter 方法的快捷生成方式，点击eclipse上面source下面有自动生成的快捷键

java的Criterion的andTdzGreaterThan java中answer_数据类型_08

将需要的勾选上，就可以了。

private int age;

此时类Person2无法使用

pe.age = 18;

那么此时更改代码如下：

package test3;

/**
 * 
 * @author hengyuzuo
 *
 */
public class Person {
	
	//成员变量
	String name;
	private int age;
	
	//成员方法
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("my name is: " + name +". my age is: " + age);
	}// Of show
	
	//专门定义了一个成员方法用来设置成员变量的数据，Setter方法
	public void setAge(int num) {
	
		//设置条件判断进行数据合理性检测
		if (num <= 0 || num >= 100) {
			System.out.println("年龄超出范围");
		}else {
			age = num;
		}// Of if
	}// Of setAge
	
	//专门定义了一个成员方法用来获取成员变量的数据，Getter方法
	public int getAge() {
		return age;
	}// Of getAge

}// Of class person

费力写个Setter 、Getter的原因就是它本身是一个成员方法，可以设置条件判断

package test3;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Person2 {
	
	public static void main(String[] args) {
		
		//创建对象
		Person pe = new Person();
		
		//成员变量赋值
		pe.name = "jing long";
		pe.setAge(200);
		
		//调用成员方法
		pe.show();	
	}// Of main

}// Of class Person2

此时，输入年龄200，就会提示数据错误，show方法会有一个默认值，int的默认值是0

年龄超出范围
my name is: jing long. my age is: 0

这就是private的用法

14.this 关键字

当局部变量和成员变量重名的时候，方法当中会根据“就近原则”使用
如果想区分，就需要使用 this.成员变量名

this关键字的金典作用就是将重名的成员变量和局部变量区分开
通过谁调用的方法，谁就是this，this代表的就是“当前对象”

例子

package test4;
/**
 * this
 * @author hengyuzuo
 *
 */
public class person {
	
	//成员变量
	String name;
	
	//成员方法
	public void sayhello(String who) {
		// TODO Auto-generated method stub
		System.out.println("你好" + who + "我是" + name);
	}

}

调用

package test4;
/**
 * 
 * @author hengyuzuo
 *
 */
public class person2 {
	public static void main(String[] args) {
		person pe = new person();
		
		pe.name = "小王";
		
		pe.sayhello("大王");

	}
}

who是对方的名字，name是自己的名字，如果将who也改成name，那么成员变量name和局部变量who重名了

package test4;
/**
 * this
 * @author hengyuzuo
 *
 */
public class person {
	
	//成员变量
	String name;
	
	//成员方法
	public void sayhello(String name) {
		// TODO Auto-generated method stub
		System.out.println("你好" + name + "我是" + name);
	}

}

此时结果你好大王我是大王 只需要在成员变量名前加 this 就可以了

15.构造方法

构造方法就是专门用来创建对象的方法，当使用new创建对象时，其实就是在调用构造方法、
如何定义一个构造方法，格式：

public 构造方法名（参数类型 参数名称）{
	方法体
	}

调用构造方法的格式就是创建对象的格式：
new 类名称（）
注意：
1.构造方法不能写返回值类型，void也没有
2.构造方法的名称必须和所在类名称完全一样，大小写也要一样

构造方法的重载
构造方法也是一种方法，所以也可以进行方法的重载（overload）
重载：方法的名称相同，但是参数列表不同（前面讲重载专门说过有几种情况）

package test5;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Student {
	
	//构造方法
	public Student() {
		System.out.println("无参数的构造方法执行");
	}
	
	//构造方法的重载
	public Student(int num) {
		System.out.println("有参数的构造方法执行");
	}

}

调用

package test5;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Constructor {
	
	public static void main(String[] args) {
		
		//调用无参数的构造方法来创建对象
		Student one = new Student();
		
		//调用有参数的构造方法来创建对象
		Student two = new Student(1);
		
	}

}

运行

无参数的构造方法执行
有参数的构造方法执行

构造方法重载的好处：
定义一个无参数的构造方法，可以直接new对象
定义一个重载的全参数的构造方法，可以new对象的同时方便对成员变量进行赋值
例子
一般一个输出名字和年龄的过程：

package test5;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Student {
	
	private String name;
	private int age;
	
	//构造方法
	public Student() {
		System.out.println("无参数的构造方法执行");
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}	
}

调用

package test5;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Constructor {
	
	public static void main(String[] args) {
		
		Student stu = new Student();
		stu.setAge(18);
		stu.setName("jing long");
		System.out.println("姓名" + stu.getName() + " 年龄" + stu.getAge());
	}
}

结果

无参数的构造方法执行
姓名jing long 年龄18

当使用构造方法后

//构造方法的重载
	public Student(String str, int num) {
		System.out.println("有参数的构造方法执行");
		name = str;
		age = num;
	}

可以直接在new的时候通过构造方法给成员变量赋值

//直接在new的使用通过构造方法给成员变量赋值
		Student stu2 = new Student("haha",15);
		System.out.println("姓名" + stu2.getName() + " 年龄" + stu2.getAge());
		
		//这里也要写get的原因是以防改变成员变量，如
		stu2.setAge(25);
		System.out.println("姓名" + stu2.getName() + " 年龄" + stu2.getAge());

运行

无参数的构造方法执行
姓名jing long 年龄18
有参数的构造方法执行
姓名haha 年龄15
姓名haha 年龄25

全参数的构造方法的快捷键生成也在source里面！！！！！！

16.定义标准的POJO类

如何定义一个”标准的类”
1.所有的成员变量都需要使用private关键字私有化（以确保数据安全）
2.为每一个成员变量编写一对 Setter 、Getter 方法
3.编写一个无参数的构造方法
4.编写一个全参数的构造方法

【注意】
对于所有的数据类型，Getter都必须叫getxxx，Setter都必须叫setxxx，但是有一个特例
如果数据类型是boolean值，那么setxxx的规则不变，而setxxx需要写成isxxx

【练习】：两个对象的邂逅
定义一个类代表“人” 含有姓名和年龄，而且具有打招呼的功能，根据类创建两个对象并赋值。让两个对象分别和对方打招呼。
创建类

package test6;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Person {
	
	//member variable
	private String name;
	private int age;
	
	//constructor
	public Person() {
	}
	
	//overload
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	//member method
	public void sayHello(String name) {
		System.out.println(name + "hello " + "i am " + this.name + " " + age +" years old");
	}

	//Setter and Getter
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
}

创建对象

package test6;

public class Constructor {
	
	public static void main(String[] args) {
		
		// default constructor
		Person one = new Person();
		one.setAge(18);
		one.setName("xiao ming ");
		
		//constructor with all parameter
		Person two = new Person("xiao wang ", 20);
		
		one.sayHello(two.getName());
		two.sayHello(one.getName());
	}
}

运行结果

xiao wang hello i am xiao ming  18 years old
xiao ming hello i am xiao wang  20 years old

17.字符串的重新认识（字符串池）

字符串是一种引用类型，字符串也是对象，对应的类是String。类的使用都需要导包，除非在同一个包下，但是当使用的目标类位于java.lang包下时也不需要导包，但是不包含子包。

对字符串的认识，借助于JDK的API文档，官方中文版使用说明

字符串创建的的常见2+1种方式（两种构造方法，一种直接赋值）
常见的两个构造方法：
public String( char[] array):参数是一个字符数组，根据字符数组的内容来创建一个字符串

package test7;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Str1 {
	
	public static void main(String[] args) {
		char[] array = {'H','e', 'l','l','o'};
		
		//根据字符数组来创建字符串
		String str1 = new String(array);
		System.out.println(array);
	}

}

输出hello

public String(char[] array, int offset, int count)：根据字符数组的一部分内容来创建字符串
参数offset代表一个数组当中的起始索引，从0开始
参数count代表取用多少个字符

package test7;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Str1 {
	
	public static void main(String[] args) {
		char[] array = {'H','e', 'l','l','o'};
		
		//根据字符数组的一部分来创建字符串
		String str1 = new String(array,2,3);
		System.out.println(str1);
	}

}

输出llo

直接赋值双引号也是一个字符串对象：String str = hello

字符串池
为了节省内存，所以引用了字符串池的设计，可以重复利用字符串

字符串池是位于堆内存当中的一小块空间，用来保存若干个字符串的地址值
字符串池当中绝对不会出现重复的字符串对应的地址，保证字符串不重复
凡是直接双引号的字符串默认都在池中，而new出来的字符串默认不在池中

对于基本类型来说，== 是进行数据内容的相同比较，对于引用类型来说，是进行地址值的相同比较
字符串是常量，创建后内容不可改变

如何进行字符串内容的比较？
public boolean equals(Object obj) 进行字符串内容比较，严格区分大小写，参数obj就是另一个对象，object也是一种类型，可以接收任何类型的数据。a.equals(b)与b.equals(a)一样

public boolean equalsIgnorecase(String str ) 忽略大小写

【练习】模拟登录
用户名不区分大小写
密码区分大小写

package test8;
import java.util.Scanner;
/**
 * 
 * @author hengyuzuo
 *
 */
public class Login {
	
	public static void main(String[] args) {
		
		String registUsername = "admin";
		String registPassword = "123456";
		
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入用户名：");
		String inputUsername = sc.next();
		System.out.println("请输入密码：");
		String inputPassword = sc.next();
		
		if(inputUsername.equalsIgnoreCase(registUsername) && inputPassword.equals(registPassword)) {
			System.out.println("登录成功");
		}else {
			System.out.println("用户名或密码错误");
		}
				
	}

}

运行结果

请输入用户名：
admin
请输入密码：
123456
登录成功

更新中…

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：单片机跑机器学习算法单片机跑系统

下一篇：Android adb切换apn adb 切换用户

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯