java学习--面向对象（第四天）

声明：由于学习所用环境为JDK1.8,文章中所有java代码均在JDK1.8环境中测试通过，如果环境发生改变，可能会有错误发生！

一、基本数据类型的包装类

1、Java语言针对所有的基本数据类型都提供了对应的包装类。

2、自动装箱、拆箱

JDK5.0中为基本数据类型提供了自动装箱(boxing)、拆箱(unboxing)功能：
(1)装箱：将基本数据类型包装为对应的包装类对象 
(2)拆箱：将包装类对象转换成对应的基本数据类型 

eg：Integer  a=5;

       int b=a;
二、字符串相关类

1、String类

 (1) String代表字符串类型，字符串的内容本身不可改变，字符串存储于“字符串常量池”中。
 (2)String的两种实例化方式
  a:直接赋值法：
     eg:  String str=“Hello World”;

内存图如下所示：

b:通过new操作符实例化：
   eg: String str=new String(“Hello World”);

内存图如下所示：

(3)一个字符串就是一个String类的匿名对象。
    所谓匿名对象，就是在堆内存中开辟了空间，但在栈内存中并没有引用指向的对象。
(4)String类常用方法
1.public String(byte[] bytes)
  使用平台的默认字符集解码，将字节数组转换为字符串

2.public String(byte[] bytes,Charset charset)
  使用指定字符集解码，将字节数组转换为字符串

3.public char charAt(int index)
  根据索引位置获取字符串中的某个字符

4.public boolean contains(CharSequence s)
  判断当前对象代表的字符串是否包含参数字符串内容

5.public boolean equals(Object anObject)
  判断字符串内容是否相同

6.public byte[] getBytes()
  将字符串转换为字节数组

7.public int indexOf(String str)
  返回参数字符串在当前字符串中的索引位置

9.public int lastIndexOf(String str)
  从后往前找参数字符串，返回参数字符串在当前字符串中的索引位置

10.public int length()
   返回当前字符串的长度

11.public String toLowerCase()
   将字符串转换为小写

12.public String toUpperCase()
   将字符串转换为大写

13.public char[] toCharArray()
   将字符串转换为字符数组

14.public String substring(int beginIndex)
   从beginIndex索引位置开始，到字符串末尾，截取字符串

15.public String substring(int beginIndex,int endIndex)
   从beginIndex索引位置开始，到endIndex-1，截取字符串

16.public String trim()
   返回一个字符串,这个字符串删除了前导和尾随空格

17.public String[] split(String regex)
   通过指定的正则表达式拆分字符串，将拆分后的结果作为一个字符串数组返回

public class StringMethod {

	public static void main(String[] args) {
		String str="中华人民共和国";
		System.out.println(str.charAt(2));  // 根据索引位置获取字符串中的某个字符
        System.out.println(str.contains("人民"));   // 判断当前对象代表的字符串是否包含参数字符串内容
        System.out.println(str.indexOf("民共和"));
        // 将"abcde"的d变为大写
        String s1="abcdedx";
        System.out.println("从后往前找d:"+s1.lastIndexOf("d"));
        String s2="wxYz";
        System.out.println(s2.toUpperCase());
        System.out.println(s2.toLowerCase());
        System.out.println("中华人民共和国".substring(3));
        System.out.println("中华人民共和国".substring(3,6));
        String s3="   中     国     人  ";
        System.out.println("s3的长度："+s3.length());
        System.out.println("删除了前后空格后的长度："+s3.trim().length());
        String country="中国,美国,俄罗斯,意大利,瑞典";
        String[] array=country.split(",");
        System.out.println("遍历拆分后的字符串：");
        for(String cou:array){
        	System.out.print(cou+"  ");
        }
	}

}

2. StringBuffer类：

(1)StringBuffer代表可变的字符序列。
  StringBuffer称为字符串缓冲区，它的工作原理是：预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。
(2)StringBuffer是可变对象，这个是与String最大的不同(如果连续操作String对象，则会产生大量的“垃圾”，而且“断开-连接”很频繁。)

public class StringBufferMethod {

	public static void main(String[] args) {
		StringBuffer sb=new StringBuffer();
		sb.append("中国").append("伟大").append("Java");
		System.out.println("反转之前：");
		System.out.println(sb.toString());
		sb.reverse();   // 反转缓冲区的内容
		System.out.println("反转之后：");
		System.out.println(sb.toString());
		
		StringBuffer sb2=new StringBuffer();
		sb2.append(false).append(12.5).append("hello");
		sb2.insert(1,true);   // 在索引为1处插入true
		System.out.println(sb2);

	}

}

3.StringBuilder类
StringBuilder和StringBuffer功能几乎是一样的， 只是 StringBuilder是线程不安全的
三、内部类
1.在类的内部定义另一个类。如果在类Outer的内部再定义一个类Inner，此时Inner就称为内部类，而Outer则称为外部类。

2.内部类的定义格式：public class 外部类名称{

                                             //外部类代码

                                             public  class 内部类名称{

                                                     //内部类代码

                   }

}

3.内部类在编译完成后也会产生.class文件，而文件名称则是”外部类名称$内部类名称.class”
4.使用内部类的优缺点

优点：(1)可以方便地访问外部类的私有属性
           (2)减少了类文件编译后的产生的字节码文件的大小
缺点：使程序结构不清楚
四、内部类的分类

1、成员内部类
成员内部类中不能定义static变量
成员内部类持有外部类的引用
在文件管理方面，成员内部类在编译完成后也会产生.class文件，而文件名称则是”外部类名称$内部类名称.class”
外部实例化成员内部类的格式：
外部类.内部类  内部类对象=外部类实例.new 内部类();

public class Outer {
   private String name="中国人";
   
   // 成员内部类
   class MemberInner{
	   public void method(){
		   System.out.println("内部类可以访问外部类的私有属性："+name);
	   }
   }
   
   public MemberInner getMemberInstance(){
	   return new MemberInner();
   }
}

2、静态内部类

如果一个内部类使用static声明，则此内部类就称为静态内部类，其实也相当于外部类。可以通过外部类.内部类来访问。
静态内部类不会持有外部类的引用，创建时可以不用创建外部类对象
静态内部类可以访问外部的静态变量，如果访问外部类的非static成员变量必须通过外部类的实例访问
外部实例化静态内部类对象的格式：
外部类.内部类  内部类对象= new  外部类.内部类();

public class Outer {
   private String name="中国";
   private static int population=14;
   
   static class StaticInner{
	   public void method(){
		   System.out.println("静态内部类直接访问外部类的static属性："+population);
		   Outer out=new Outer();
		   System.out.println("在静态内部类中通过外部类对象访问非static属性："+out.name);
	   }
   }
   
   public static StaticInner getStaticInner(){
	   return new StaticInner();
   }
}

3、局域内部类

局域内部类是定义在一个方法中的内嵌类，所以类的作用范围仅限于该方法中，而类生成的对象也只能在该方法中使用。
局域内部类不能包含静态成员

特别注意：局域内部类要想访问包含其的方法中的参数，则方法中的参数前必须加上final关键字(JDK<=1.7)。

public class Outer {
   private  String name="中国";
   public void func(int x){
	    class LocalInner{
		   public void method(){
			   System.out.println("局域内部类访问外部类的属性："+name);
			   System.out.println("局域内部类访问包含其方法的参数"+x);
		   }
	   }
	    
	   new LocalInner().method();   // 在局域内部类所在的方法中实例化局域内部类对象，并调用其方法
   }
}

4、匿名内部类(最常用)

如果一个内部类在整个操作中只使用一次的话，就可以定义为匿名内部类
没有名字的内部类，这是java为了方便我们编写程序而设计的一个机制，因为有时候有的内部类只需要创建一个它的对象就可以了，以后再不会用到这个类，这时候使用匿名内部类就比较合适

public interface Jumping {
    public void jump();
}

public class TestAnonumity {

	public static void main(String[] args) {
		Jumping j=new Jumping(){

			@Override
			public void jump() {
				System.out.println("某人跳楼了...");
			}
			
		};
		j.jump();

	}

}