标签：String 2021.6 28 System final Java5 println public out

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

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修饰的类不可以有子类

标签：String,2021.6,28,System,final,Java5,println,public,out
来源： https://blog.csdn.net/weixin_59568478/article/details/118273724

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。