Java 学习 第五篇；面向对象

1:基本数据类型的拆装；
基本变量类型 通过 new WrapperClass（primitive） 创建包装类对象；
包装类的对象 通过 WrapperInstance.XXXValue() 获取包装类对象的值；
例如
int it=5；
Integer itObject=new Integer（it）；装包
it = itObject.intValue(); 拆包取出变量值；
<实际上java提供了自动装箱，自动卸箱的功能可以直接赋值>
2：基本类型变量和字符串之间的转换；
String intstr="123" ,intstr2="3.34";
int it =Integer.parseInt(intstr);
Float.parseInt(intstr2);
......

 public static void main(String[] args)
 {

 String str="232423";
 String str1="23.45";
 //字符串转换为其他类型
 int intstr=Integer.parseInt(str);
 float flostr=Float.parseFloat(str1);
 System.out.println(intstr);
 System.out.println(flostr);
 //232423
 //23.45
 //其他类型转换为字符串
 String str2=String.valueOf(intstr);
 System.out.println(str2);
 //
 }

3:equals & ==

String 已经重写了 Object的equals()方法通过equals判断两个字符串是否相等；标准是只要两个字符串包含的字符序列相同即认为相等；
public boolean equals（Object obj）；为其原型；

String str ;
String str1;
str="222";
str1="222";

if(str==str1)
System.out.println("true1");

str =new String("222");
str1=new String("222");

if(str==str1)
System.out.println("true2");

if(str .equals(str1) )
System.out.println("true3");

output:

true1
true3
4：再次警示一下为什么static关键字修饰的成员不能访问实例成员
那是因为呀 很久很久以前.......是因为static修饰的是类成员(包括初始化块、方法、内部类和枚举类)，类成员作用域大呀，很可能在类成员已经初始化完成
但是实例成员还没有初始化，也就是说实例成员可能还没哟实际存在只是一个引用而已（我的意思是举个栗子实例成员是变量的话）所以那怎么可以随便访问
不能，明显不能.
5:一种特殊的类 -----只能创建一个对象；计划生育的良好贯彻，只准有一个；
如何实现呢：答案很简单---->>>>>隐藏构造器，将构造器用private修饰, 另外得保证时刻得知道有没有创建这个类的对象，所以最好，缓存已经创建的对象，
让后再保证只创建一次就行了，如何保证，看看缓存是否存在呗，有的话就不能继续创建没有的话可以；
举个栗子：

class OnlyOne
{
private static OnlyOne instance;
private OnlyOne(){};
public static Onlyone getInstance()//为什么多了这个呢？为了判断呗 如果有申请创建新的对象，那么根据情况进行判断， 为什么是public？因为总得创建一次
{
if(instance==null)
instance=new OnlyOne;
return instance;
}

}

可以测试下 新建两个对象 看看是否==

6：final 用于修饰不可变的类、方法、变量。
可修饰成员变量、局部变量 形参 等等 很类似与const of Cpp;（我是这么认为的）
一旦获取初始化之后就不能被再次赋值;
执行静态初始快块时为类属性赋初值;执行普通初始化快和构造器时可以为实例属性赋初值；
如果定义的final实例属性变量，如果没有及时为之赋初值，即没有在初始化块中、没有在构造器中、没有在初始化时、对其进行赋初值那么定义这个变量有毛用啊，
都TM系统默认了！
记住！ 1：final修饰的类属性不能在普通初始化块中赋初值，如果要赋就在静态初始化快中赶紧初始化，因为在加载类的时候系统已经为其初始化完毕;
2：没有初始化不要访问！
3:final 修饰的局部变量 系统不会对其进行“隐式初始化”所以可以
4:final 修饰引用类型，与基本类型有区别，修饰引用类型时只能保证其引用的未知不变“相当于指针的值不变”但是引用的具体内容是可以更改的并且也是合法的；
final 修饰方法：
修饰方法时候，该方法就不能被重写了，注意是不能重写而不是不能重载！
特数情况是 如果父类方法有private修饰时，即便加final 因为该方法对父类是不可见的那么，子类中当然可以再写一个相同的；

7：还有就是所谓的不可变类通过限定其对类的改变、所谓的缓存不可变类；
8：重点是：抽象类 abstract 抽象类和抽象方法 抽象类 顾名思义 从很多类中抽象出来的类没，更具有一般性的类；
-> 抽象类不能被实例化，即不能用new 创建一个抽象类的对象；
-> 抽象方法没有方法体，不能有
-> 抽象类只能被继承；
-> 抽象类可以有构造器，虽然他不能创建实例，但是有构造器主要是用于被其子类调用；
-> 含有抽象方法的类必须定义被抽象类；抽象类可以有普通方法哦
-> 没有抽象变量，抽象属性，抽象构造器的说法！
-> 不能用static和abstract同时修饰一个方法，因为抽象方法没有方法体，通过类调用肯定会出错！
-> abstract修饰的方法一定要被子类重写，所以不能用private修饰；即两者不能同时使用
-> 父类普通方法依赖于一个抽象方法，那么该方法仍然必须推迟到子类中实现；
对抽象类定义下吧：抽象类体现的是模板思想，抽象抽象抽象！！！！！！避免子类设计的随意，子类可以以此为模板进行扩充、改造。
例子：

 package five;

 abstract class Abstract {
 {
 System.out.println("hello abstract");
 }
 private String color;
 public abstract String xiangtongxingwei1();
 public Abstract(){};
 public Abstract(String color)
 {
 System.out.println("using Constructor wiht one parameter");
 this.color=color;
 }
 public String getcolor()
 {
 return this.color;
 }

 }
 class Example extends Abstract
 {
 public Example(String str)
 {
 super("str");
 System.out.println("using Constructor example wiht one parameter");
 }
 public String xiangtongxingwei1()
 {
 System.out.println("xiangtongxingwei1");
 return "I am an example";
 }
 }

 public class TestAbstract
 {
 public static void main(String[] args)
 {
 String str="ssss";
 Example exa1=new Example(str);
 str=exa1.xiangtongxingwei1();
 System.out.println(str);
 }
 }

output：

hello abstract
using Constructor wiht one parameter
using Constructor example wiht one parameter
xiangtongxingwei1
I am an example