自动装箱和自动拆箱：注意类型匹配

package practice;
import java.util.*;
public class Main{
	public static void main(String[] args) {
		Integer inObj=5;//装箱
		Object boolObj=true;//装箱
		int it=inObj;//拆箱
		if(boolObj instanceof Boolean) {
			boolean b=(Boolean)boolObj;//拆箱
			System.out.println(b);
		}
	}
}

包装类下有比较方法：Boolean.compare（ ，）；
包装类可以实现基本类型变量和字符串之间的转换
字符串类型转换为基本类型值：
1、利用parseXxx（String S）静态方法
2、利用包装类提供的Xxx（String S）的构造器
基本变量转换为字符串：
1、String类提供了多个重载valueOf（）方法，用于将基本变量转换成字符串
2、String intStr=5+" ";

package practice;
import java.util.*;
public class Main{
	public static void main(String[] args) {
		String intStr="123";
		int it1=Integer.parseInt(intStr);
		int it2=new Integer(intStr);
		System.out.println(it2);
		String floatStr="4.56";
		float ft1=Float.parseFloat(floatStr);
		float ft2=new Float(floatStr);
		System.out.println(ft2);
		String ftStr=String.valueOf(2.435f);
		String ftStr=String.valueOf(3.445);
		String boolStr=String.valueOf(true);
	}
}

打印对象和ToString方法
打印对象

package practice;
import java.util.*;
class Person{
	private String name;
	public Person(String name) {
		this.name=name;
	}
}
public class Main{
	public static void main(String[] args) {
		Person p=new Person("孙悟空");
		System.out.println(p);//println方法只能在控制台输出字符串，p是person内存中的对象	
	}
}

System.out.println§=System.out.println(p.toString());
to.String()
1、是Object类里的一个实例方法，所有Java类都是object类的子类，所有Java对象都有这个方法
2、所有java对象都可以和字符串进行连接运算，此时系统自动调用toString（）方法的返回值和字符串进行连接运算
String a=b+" “;
String a=b.toString()+” ";是一样的
3、该方法总是返回该对象实现类“类名+@+hashCode”
4、如果用户需要自定义类能实现“自我描述”信息的功能，就必须重写toString（）

package practice;
import java.util.*;
class Apple{
	private String color;
	private double weight;
	public Apple() {}
	public Apple(String color,double weight) {
		this.color=color;
		this.weight=weight;
	}
	public void getColor(String color) {
		this.color=color;
	}
	public void getWeight(double weight) {
		this.weight=weight;
	}
	public String setColor() {
		return color;
	}
	public double setWeight() {
		return weight;
	}
	public String toString() {
		return color+weight;
	}
}
public class Main{
	public static void main(String[] args) {
		Apple a=new Apple("红色",5.68);
				System.out.println(a);
	}
}

Java里有两种测试变量是否相等的办法
一、利用==运算符
两个变量均是基本类型变量，且都是数值类型（不一定要求数据类型严格相同），只要两个值相等返回true
但是对于两个引用变量两者要指向同一个对象时才行
不可用于比较类型上没有父子关系的两个对象

package practice;
import java.util.*;
public class Main{
	public static void main(String[] args) {
		int it=65;
		float fl=65.0f;
		System.out.println(it==fl);
		char ch='A';
		System.out.println(it==ch);
		String str1=new String("hello");//t
		String str2=new String("hello");//t
		System.out.println(str1==str2);//f分别通向两个通过new创建的String对象所以不同，如果是直接赋值进入常量池就是true
		System.out.println(str1.equals(str2));//t
	}
}

ps：String str1=“hello”;与String str1=new String(“hello”);的不同：
前者直接在常量池里创建对象
后者既先在常量池里创造对象，又后在调用String构造器创建一个实例对象，一共产生了两个对象
二、利用equals（）方法
重写equals（）方法

package practice;
import java.util.*;
class Person{
	private String name;
	private String idstr;
	public Person() {}
	public Person(String name,String idstr) {
		this.name=name;
		this.idstr=idstr;
	}
	public boolean equals(Object obj) {
		if(this==obj) {
			return true;
		}
		if(obj!=null&&obj.getClass()==Person.class) {//返回Class类型的对象： Class c = p.getClass();
//此时c是Class类型，Class提供了一系列的方法来获取类的相关信息，可以通过对象c来获取Person的信息。比如，获取Person这个类的类名：
//String perName = c.getName();
//此处不能用instanceOf因为这个是子类或者同一类都能返回true
			Person personObj=(Person) obj;
			if(this.getIdstr().equals(personObj.getIdstr())) {
				return true;
			}
		}
		return false;
	}
}

当使用实例来访问类成员时，实际上依然是委托给该类来访问类成员，因此即使某个是咧是null，它也可以访问所属类的类成员
如果null对象访问实例变量和实例方法那就会报错，实例不存在，实例变量实例方法就不存在

package practice;
import java.util.*;
public class Main{
	private static void test() {
		System.out.println("static修饰的方法");
	}
	public static void main(String[] args) {
		Main a=null;
		a.test();
	}
}

单例类的实现

package practice;
import java.util.*;
class Singleton{
	private static Singleton instance;//使用一个类变量来缓存曾经创建的实例
	private Singleton() {	}//隐藏构造器
	public static Singleton getInstance() {
		if(instance==null) {
			instance=new Singleton();
		}
		return instance;
	}
}
public class Main{
	public static void main(String[] args) {
		//创建对象不能通过构造器
		//只能通过方法来实现
		Singleton s1=Singleton.getInstance();
		Singleton s2=Singleton.getInstance();
		System.out.println(s1==s2);//t
	}
}

关于final
1、可用于修饰类，变量，方法，表示该量不可改变
2、final修饰的成员必须由程序员显式指定初始值，系统不会对final成员进行隐式初始化
类变量特点：能通过类名和实例访问，若用实例访问值会随实例的调用而改变
类变量只能在静态初始化块里或者声明量时指定初始值。
实例变量特点：只能通过实例进行访问，只能改变实例引用的复制量，不改变实例变量的值
实例变量只能在非静态初始化块，声明该变量，或构造器中指定初始值。

package practice;
import java.util.*;
public class Main{
	final int a=6;
	final String str;
	final int c;
	final static double d;
	{
		str="hello";
	}
	static {
		d=5.6;
	}
	public Main() {
		c=1;
	}
}

3、系统不会对局部变量初始化，final可以修饰形参

package practice;
import java.util.*;
public class Main{
	public void test(final int a) {
		//a=5
		//不能对final修饰的形参赋值
	}
	public static void main(String[] args) {
		final String str="hello";
		final int a;
		a=6;//第一次就不违法
	}
}

4、final修饰引用变量时是保证地址不变，其内容可以发生变化

package practice;
import java.util.*;
class Person{
	private int age;
	public Person(int age){
		this.age=age;
	}
}
public class Main{
	public static void main(String[] args){
		final int[] iArr= {5,6,12,9};
		System.out.println(Arrays.toString(iArr));//对地址进行排序
		Arrays.sort(iArr);
		System.out.println(Arrays.toString(iArr));//对地址进行排序
		iArr[2]=-8;
		System.out.println(Arrays.toString(iArr));
		final Person p=new Person(45);
		p.setAge(23);
		System.out.println(p.getAge());
	}
}

5、变量若满足以下三个条件就相当于宏替换
（1）使用final修饰
（2）定义final变量时指定了初始值
（3）该初始值在编译时就被确定下来，若需要调用方法则就不是
6、final修饰的方法不能子类重写，即使子类中有一模一样的方法，那也是新创建不是重写，但是可以重载哦~
7、final修饰的类不可以有子类