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);
......

 1 public static void main(String[] args)

 2 {

 3 

 4 String str="232423";

 5 String str1="23.45";

 6 //字符串转换为其他类型

 7 int intstr=Integer.parseInt(str);

 8 float flostr=Float.parseFloat(str1);

 9 System.out.println(intstr);

10 System.out.println(flostr);

11 //232423

12 //23.45

13 //其他类型转换为字符串

14 String str2=String.valueOf(intstr); 

15 System.out.println(str2);

16 //232423

17 }

View Code

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");

View Code

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;

}



}

View Code

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

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修饰；即两者不能同时使用
-> 父类普通方法依赖于一个抽象方法，那么该方法仍然必须推迟到子类中实现；
对抽象类定义下吧：抽象类体现的是模板思想，抽象抽象抽象！！！！！！避免子类设计的随意，子类可以以此为模板进行扩充、改造。
例子：

 1 package five;

 2 

 3 abstract class Abstract {

 4 {

 5 System.out.println("hello abstract");

 6 }

 7 private String color;

 8 public abstract String xiangtongxingwei1();

 9 public Abstract(){};

10 public Abstract(String color)

11 {

12 System.out.println("using Constructor wiht one parameter");

13 this.color=color;

14 }

15 public String getcolor()

16 {

17 return this.color;

18 }

19 

20 }

21 class Example extends Abstract

22 {

23 public Example(String str)

24 {

25 super("str");

26 System.out.println("using Constructor example wiht one parameter");

27 }

28 public String xiangtongxingwei1()

29 {

30 System.out.println("xiangtongxingwei1");

31 return "I am an example";

32 }

33 }

34 

35 public class TestAbstract

36 {

37 public static void main(String[] args)

38 {

39 String str="ssss";

40 Example exa1=new Example(str);

41 str=exa1.xiangtongxingwei1();    

42 System.out.println(str);

43 }    

44 }

View Code

output：

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