标签:cer 单例类 引用数据类型 非静态内部类 同名 outer 转换 多个 equal
String intStr="123"; int it1=Integer.parseInt(intStr); int it2=new Integer(intStr);
int it3=111; String s=String.valueOf(it3); String booleanStr=String.valueOf(true);
String s=5+"";
Integer a=new Integer(6); System.out.println("6的包装类实例是否大于5.0"+(a>5.0));
new Integer(2)==new Integer(2); //false
Integer a=2; Integer b=2; a==b; //true Integer c=128; integer d=128; c==d; //false
class Person{ private String name; public Person(String name){ this.name=name; } } public class PrintObject{ public static void main(String[] args){ Person p=new Person("lyy"); System.out.println(p); } }
打印出这个对象,结果为Person@15db9742,实际上Person实例是一个内存中的对象,不可以直接转换成字符串输出。但是实际上,这里输出 的是Person对象的toString()方法的返回值,这里的p跟p.toString()效果是一样的。toString()方法是一个“自我描 述”方法,当程序员直接打印该对象时,系统会输出该对象的自我描述信息,用以告诉外界该对象具有的状态信息。toStrng()方法返回的是“类名+@+hashCode”
用==进行判断时,如果都是基本数据类型,且值相等,就返回true;如果是两个引用类型,只有指向同一个对象,==判断才会返回true,如:
int a=65; float b=65.0f; a==b; //true char c=‘A‘; a==c; //true String str1=new String("hello"); String str2=new String("hello"); str1==str2; //false str1.equals(str2); //true String str3="hello"; String str4="hello"; str3==str4; //true
public class Person{ private String name; private String idStr; public Person(String name,String idStr){ this.name=name; this.idStr=idStr; } public boolean equals(Object obj){ //如果两个对象是同一个对象 if(this==obj) return ture; //只有当obj是Person对象 if(obj!=null&obj.getClass()==Person.class){ Person p=(Person)obj; //并且当前对象的idStr与obj对象的idStr相等时才可以判断两个对象相等 if(this.getIdStr().equals(p.getIdStr())) { return true; } } return false; } }
7.static关键字
public class Singleton{ private static Singleton instance=null; private Singleton(){} public static Singleton getInstance(){ if(instance==null){ instance=new Singleton(); } return instance; } }
饿汉式
public class Singleton{ private static Singleton instance=new Singleton(); private Singleton(){} public static Singleton getInstance(){ return instance; } }
8.final
final关键字可用于修饰类、变量和方法,final修饰的变量不可被改变,一旦获得了初始值,该final变量的值就不能被重新赋值。final可提高程序响应效率,声明成final的情况:
(1)不需要重新赋值的变量,包括类属性、局部变量;
(2)对象参数前加final,表示不允许修改引用的指向;
(3)类方法确定不允许被重写;
二 内部类
(1)非静态内部类:
public class Cow { private double weight; public Cow(double weight) { this.weight = weight; } public Cow() { } //非静态内部类 private class CowLeg{ private double length; private String color; public CowLeg(double length, String color) { this.length = length; this.color = color; } public CowLeg() { } public void info(){ System.out.println("牛腿颜色:"+color+",高:"+length); //可以访问到外部类的private修饰的成员变量 System.out.println("奶牛重:"+weight); } } public void test(){ CowLeg cl=new CowLeg(1.12,"白加黑"); cl.info(); } public static void main(String[] args){ Cow cow=new Cow(378.9); cow.test(); } }
注意:如果外部类成员变量、内部类成员变量和内部类方法里的局部变量同名,可以通过使用this,外部类类名.this来区分,如:
public class DiscernVariable { private String prop="外部类的实例变量"; private class innerClass{ private String prop="内部类的实例变量"; public void info(){ String prop="局部变量"; //外部类的实例变量 System.out.println(DiscernVariable.this.prop); //内部类的实例变量 System.out.println(this.prop); //局部变量 System.out.println(prop); } } public void test(){ innerClass in=new innerClass(); in.info(); } public static void main(String[] args){ new DiscernVariable().test(); } }
通过上面两个例子我们可以发现,如果存在一个非静态内部类对象,那么久一定存在一个被它寄生的外部类对象,如:
public class Outer { private int outProp=9; class Inner{ private int inProp=5; public void accessOutProp(){ System.out.println("外部类的outProp的值:"+outProp); } } public void accessInnerProp(){ //这段代码出现编译错误,外部类不能直接访问非静态内部类的实例变量 // System.out.println("内部类的inProp的值:"+inProp); //必须要显式创建内部类来访问内部类的实例变量 System.out.println("内部类的inProp的值:"+new Inner().inProp); } public static void main(String[] args){ //只是创建了外部类对象,并没有创建内部类对象 Outer out=new Outer(); out.accessInnerProp(); } }
(2)静态内部类
public class StaticInnerClassTest { private int prop1=5; private static int prop2=3; static class StaticInnerClass{ private static int age; public void accessOurProp(){ //无法访问外部类的实例变量 // System.out.println(prop1); System.out.println(prop2); } } }
3.在外部类以外使用内部类
(1)非静态内部类:
class Out{ class In{ public In(String msg){ System.out.println(msg); } } } public class CreateInnerInstance { public static void main(String[] args){ Out.In in=new Out().new In("测试信息"); } }
class StaticOut{ static class In{ public StaticIn(String msg){ System.out.println("静态内部类的构造器"); } } } public class CreateStaticInnerInstance { public static void main(String[] args){ StaticOut.StaticIn in=new StaticOut().StaticIn(); } }
标签:cer 单例类 引用数据类型 非静态内部类 同名 outer 转换 多个 equal
原文地址:http://www.cnblogs.com/lyy-2016/p/6339708.html