Java认识对象

目录

• Java认识对象
  • 1. 类与对象
    • 1.1 定义
    • 1.2 标准类
      • 1.2.1 java.util.Scanner
      • 1.2.2 java.math.BigDecimal
      • 1.2.3 对象指定与相等性。
  • 2. 经典打包器
    • Java基础类型包装类。
      • 1. 数值类包装类。
        • 基本数据类型与它的包装类的转换
        • 数值类包装类的使用1，协助int与String之间的转换
        • 数值类包装类的使用2，常用的方法和属性。
        • Character的常用方法：
  • 3. 数组
    • 3.1 数组的定义方式：
    • 3.2 动态数组的使用(ArrayList)：
  • 4. 字符串（String类和StringBuilder类）
    • • String类的一些小细节。
      • String类的不可变性。

Java认识对象

1. 类与对象

关系：

• 类是对象的模板。
• 对象是类的实例化。（在Java中对象和实例几乎是对等的含义）

1.1 定义

• 类的定义方式是class + 类名
• 特别地，一个文件中有且仅能有一个公共类(public class),并且该类的类名必须与文件名同名。
• 类可以包含类自己的状态和方法。
• 另外，只要有一个类定义，编译程序就会产生一个.class文档。

public class Main4 {
	//类的属性
	String main_name;
	int main_numb;
	
	//无参数的构造方法
	public Main4() {
		System.out.println("这里是无参数的构造方法");
	}
	//有参数的构造方法
	public Main4(String main_name, int main_numb) {
		this.main_name = main_name;
		this.main_numb = main_numb;
		System.out.println("这里是有参数的构造方法");
	}
	//类方法
	private void GetMain4_Name() {
	}
	//主函数接口
	public static void main(String[] args) {

	}
}

1.2 标准类

1.2.1 java.util.Scanner

• Scanner可以支持按不同的数据类型来读取信息，想要输入的信息是什么类型的，就用对应的nextXXXX()来读取数据就好。
• 确定不使用Scanner则应该使用sc.close()来将其关闭。

1.2.2 java.math.BigDecimal

• 由于浮点数的机器表示法所存在的浮点误差产生了以上的程序错误使得程序得不到我们想要的结果。
• 所以在遇到这种情况的时候，就可以考虑用java.math.BigDecimal这个标准类来解决这个问题了。
  

1.2.3 对象指定与相等性。

• 对基本类型而言。
  • =的效果就是把值赋值给某一个变量，在基本类型中，变量和它存储的值我们可以视为同一个存在。
  • ==的效果就是判断两个变量的值是不是一致。
• 当操作对象时。
  • =的效果就是用指定的参考名称来参考某个对象，同俗地来讲就是我们给某一个对象挂上了一个名牌，我们可以用这个名牌联系到对象，但是本质上名牌和对象是两个东西，只不过存在一一对应关系而已。
  • ==的效果就是判断两个接受比较的存在本身，而不是比较他们背后的关系。比如在程序中使用a == b实际上是在问，a名牌和b名牌是不是挂在同一个对象上？而在操作对象中，我们如果要实际地去比较两个名牌所挂的对象的内容是不是相同，我们就需要使用a.equals(b)

2. 经典打包器

• 在进行面向对象编程的时候，由于存在基本类型也需要介入面向对象编程的体制下，所以Java中基本类型有他们对应的包装类。
  
• 自动装箱：当基本类型参与一些对象操作的时候，Java会把基本类型自动包装成它们对应的包装类来进行面向对象的操作。
• 自动拆箱：当基本类型的包装类要涉及到一些计算或者需要直接用到值和内容的时候，Java会对基本类型的包装类拆包取出他们的内容来参与运算。

Java基础类型包装类。

1. 数值类包装类。

基本数据类型与它的包装类的转换

• 不建议使用new来创建对象!
• Integer的类型转换(other -> Integer)：
  • 使用的是valueOf的方法。
  • Integer的valueOf(int i);
  • Integer的valueOf(String str);
  • Interger i = Interger.valueOf(String , 原数据进制);
  • Integer x = Integer.valueOf("10",2); // x=2， "10"在2进制中表示2。
• Integer的类型转换(Integer -> other)：

Integer x = Integer.valueOf(3);
int numb1 = x.intValue();  //Integer->int
long numb2 = x.longValue();  //Integer->long

数值类包装类的使用1，协助int与String之间的转换

//将字符串转换成int
int numb1 = Integer.parseInt("10");
System.out.println(numb1);
//将16进制的字符串数字，转化成10进制数字
int numb2 = Integer.parseInt("F", 16);
System.out.println(numb2);
int numb3 = Integer.parseInt("f", 16);
System.out.println(numb3);
//F和f都对应表示10进制的15。
//将int转化成String
String str1 = Integer.toString(numb1);
System.out.println(str1);
//将10进制的数字，转化成对应的16进制的String
String str2 = Integer.toHexString(255);
System.out.println(str2);

数值类包装类的使用2，常用的方法和属性。

• Integer最大值和最小值：
  
• Double的最大值和最小值，以及正无穷与负无穷：
  
• 特别注意，浮点数是不准确的，所以在比较浮点数的时候，不能直接使用==，而应该使用Double类自带的方法compare(double1 , double2)来比较两个浮点数是否一样。

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		double double1;
		double double2;
		while(sc.hasNext())
		{
			double1 = sc.nextDouble();
			double2 = sc.nextDouble();
			if(Double.compare(double1, double2) == 0)
			{
				System.out.println("相等");
			}
			else if (Double.compare(double1, double2) > 0)
			{
				System.out.println("double1大于double2");
			}
			else
			{
				System.out.println("double1小于double2");
			}
		}
		sc.close();
	}
}

• 测试样例以及输出

1.2 1.2
相等
1.2 1.3
double1小于double2
1.3 1.2
double1大于double2

• 对于compare()
  • 当double1等于double2时返回0；
  • 当double1小于double2时返回<0；
  • 当double1大于double2时返回>0；

Character的常用方法：

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//Character类的常用方法
		Character ch = Character.valueOf('a');
		if(Character.isLetter(ch))
		{
			System.out.println("是字母");
		}
		ch = Character.valueOf('1');
		if(Character.isDigit(ch))
		{
			System.out.println("是数字");
		}
		ch = Character.valueOf(' ');
		if(Character.isWhitespace(ch))
		{
			System.out.println("是空白字符");
		}
		ch = Character.valueOf('F');
		if(Character.isUpperCase(ch))
		{
			System.out.println("是大写字母");
		}
		System.out.println(ch+"变成"+Character.toUpperCase(ch));
		ch = Character.valueOf('f');
		if(Character.isLowerCase(ch))
		{
			System.out.println("是小写字母");
		}
		System.out.println(ch+"变成"+Character.toLowerCase(ch));
		String str = Character.toString(ch);
		System.out.println("变成字符串"+str);
		sc.close();
	}
}

• 对应的输出

是字母
是数字
是空白字符
是大写字母
F变成F
是小写字母
f变成f
变成字符串f

Java中的Integer常量池的概念：
Java Integer 常量池

3. 数组

• 数组也是引用类型。
• 数组在访问的时候要记得实际存在的数组长度不要出现数组下标越界的情况！
• 访问数组可以使用for循环也可以使用for-each循环。

3.1 数组的定义方式：

• 可以在定义的时候直接赋值。
• 可以在定义的时候进行动态内存申请。
• 声明二维数组的时候，可以对第二维度的空间逐个动态开辟他们的空间大小，不一定要求开辟的空间是整齐划一的。

import java.util.Scanner;
import java.util.Arrays;
public class Main4 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		//声明一个数组并直接赋初值
		double[] arr_dou = {1.2,1.3,1.4,1.5,1.6};
		for (int i = 0; i < arr_dou.length; i++) {
			System.out.println(arr_dou[i]);
		}
		//声明一个数组并动态开辟空间。
		int[] arr_numb = new int[10];
		for (int i : arr_numb) {
			System.out.print(i+" ");
		}
		System.out.println();
		//声明二维数组/允许不规则化
		int[][] diarr = new int[2][];
		diarr[0] = new int[2];
		diarr[1] = new int[3];
		{
			diarr[0][0] = 1;
			diarr[0][1] = 1;
			diarr[1][0] = 2;
			diarr[1][1] = 2;
			diarr[1][2] = 2;
		}
		for (int[] is : diarr) {
			System.out.println(Arrays.toString(is));
		}
		sc.close();
	}
}

3.2 动态数组的使用(ArrayList)：

• ArrayList（菜鸟教程的官方链接解释）

1. 其内部的存储空间可以动态调整，也就是说它的长度是可以随着需求自己扩张的。
2. 它无法存放基本类型的数据，只能存放引用类型的数据。
3. 常用的方法有：
   • add() : 用于添加一个元素；
   • remove()：用于移除一个元素 ；
   • get() ：用于获取一个元素 ；
   • size()：用于获取当前数组的长度 ；
   • contains()：用于判断某一个元素是否存在于当前数组 ；
   • isEmpty()：用于判断当前的数组是否为空。

4. 字符串（String类和StringBuilder类）

String类的一些小细节。

创建字符串的变量有两种办法，一种是直接创建，另一种是以类的形式创建，我们发现，对于类的String只能通过类自带的方法来对他们进行操作，而不直支持用==来判断他们之间是否相等了。

import java.io.InputStream;
import java.util.Scanner;

public class Main 
{
	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);
		String str1 = "lqs";
		String str2=  "lqs";
		String str3 = new String("lqs");
		String str4 = new String("lqs");
		System.out.println(str1 == str2);
		System.out.println(str1.equals(str2));
		System.out.println(str3 == str4);
		System.out.println(str3.equals(str4));
		in.close();
	}
}

• str3 和 str4 用==进行比较之所以会结果为false的原因是，他们是用new创建的，而String类的本质是引用数据类型，str3和str4存储的并不是对象的值，而只是他们的引用的值（可以理解为地址），他们存储的地址是不同的，所以str3自然不等于str4，但是.equals()则不同，这是类的方法，它是取对象的值（可以理解为取对应地址的内容）来进行比较。
• 此时再来理解明明String是引用数据类型那str1和str2应该保存的也是引用，怎么这里确一样了呢？原因是，他们创建的办法是用常量的方式来创建，而当String类用常量的方式来创建的时候，都会先在字符串常量池中先进行寻找看对应的常量字符串是否已经存在，如果已经存在的话就不再创建新的字符串常量，反之，如果不存在的话，那就会创建新的字符串常量。

String类的不可变性。

• 对某一个String对象进行其他运算并再次赋值后，原本对象并不会被改变，而是将运算的结果新创建了一个对象，并让当前的引用数据类型，指向了新创建的这个变量的引用而已。

String x = "I like";
x = x + " Java.";

• 所以当我们需要对字符串进行频繁修改的时候，我们最好使用StringBuilder

可变动字符串类：StringBuilder