Java认识对象

一、类与对象

java中有基本类型和类类型两个类型系统。Java撰写程序几乎都在使用对象，要产生对象必须先定义类，类是对象的设计图，对象是类的实例

1.定义类

类定义使用的关键词为class，建立实例的使用关键词new。在下面的代码中定义了两个类，一个是公开的Field类所以文档的主文档名必须是Field，另一个是非公开的的类Clothes。一个原始码中可以有多个类定义但是只能有一个公开类，主文档名称必须与公开类名称相同。只要有一个类就会产生一个字节码文档。所以下面代码编译会有两个字节码文档。

 class Clothes{
     String color;
     char Size;
     clothes(String color,char Size){//构造函数是与类同名称的方法
         this.color=color;
         this.Size=size
     }
 }
 public class Field{
     public static void main(String[] args) {
         Clothes  sun=new Clothes();
         Clothes spring=new Clothes();
         Clothes  sun1=new Clothes("red",'M');//使用指定的构造函数建立对象
         Clothes spring1=new Clothes("yellow",'L');
         sun.color="red";
         sun.Size='S';
         spring.color="green";
         spring.Size='M';
     }
 }

2.使用标准类

1.使用Java.util.Scanner

scanner实例会帮你扫描标准输入。nextInt方法会看在标准输入中有没有下一个字符串（以空格会换行分隔），有的话尝试剖析为int类型。Scanner对应每个基本类型都有nextXxx()方法，如果直接去的下一个字符串用next()（以空格或换行分隔），如果想去取得一整行文字则用nextLine()（以换行分隔）

 import java.util.Scanner;//告诉编译程序接下来你想偷懒不想每次都输入java.util.Scanner public class guess {
     public static void main(String[] args) {
         Scanner scanner=new Scanner(System.in);//建立Scanner实例必须传入java.io.InputStream的实例，System.in就是一种InputStream
         int number=(int)(Math.random()*10);
         int guess;
         do {
             System.out.println("猜数字（0~9）：");
             guess=scanner.nextInt();//取得下一个整数
         }while(guess!=number);
         System.out.println("猜对了");
     }

 }

2.使用java.math.BigDecimal

1.0-0.8!=0.2为什么呢？原因是Java（包括其他程序语言）遵守IEEE754浮点数运算规范，使用分数和指数俩表示浮点数。如0.5使用1/2,0.1使用1/16+1/32+1/256+1/4096+.....无限循环下去，无法精确表示造成运算上的误差。

double a=0.1;
double b=0.2;
if((a+b)=2)
{
    System.out.println("等于0.2");
}
else{

     System.out.println("不等于0.2");
}//结果是不等于0.2.所以要求精确度，要小心使用浮点数，而且别用==直接比较浮点数运算结果

得到更好精确度的办法如下

     BigDecimal op1=new BigDecimal("1.0");
     BigDecimal op2=new BigDecimal("0.8");
     BigDecimal result=op1.subtract(op2);//BigDecimal提供了plus()、substract()、multiply()、divide()等方法；
     System.out.println(result);//结果是等于0.2

 BigDecimal op3=new BigDecimal("0.1");
         BigDecimal op4=new BigDecimal("0.1");
         BigDecimal result1=new BigDecimal("0.2");
         if(op3.add(op4).equals(result1)) {
             System.out.println("等于0.2");
         }else {
             System.out.println("不等于0.2");

         }

3.对象指定与相等性

对于基本类型的话，=是将值赋给某个变量，==是比较两个变量存储的值是否相等

int a=10;
int b=10;
int c=a;
Syetem.out.println(a==b);//true
Sysytem.out.println(a==c);//true

对于对象的话，=是指定参考名称参考某个对象，而==是用在比较两个参考名称是否参考统一对象

BigDecimal a=new BigDecimal("0.1");
BigDecimal b=new BigDecimal("0.1");
BigDecimal c=a;
System.out.println(a==b);//false;

System.out.println(a==b);//true;

System.out.println(a.equals(b));//true

二、基本类型打包器

1.打包基本类型

基本类型的打包器都归于Java.lang中，在Integer打包int类型数据，方法之一就是用new创建Integer实例传入int类型数据（1）。Integer提供compareTo()方法，可与另外一个Integer比较，如果打包值相同就返回0；小于传入对象的值就返回-1.否则就是1（2）

int data1=10;
int data2=20;
Integer wrapper1=new Integer(data1);//打包基本类型（1）
Integer wrapper2=new Integer(data2);
System.out.println(data1/3);//基本类型运算结果为3
System.out.println(wrapper1.doubleValue()/3);操作打包器的方法结果为3.3333...
System.out.println(wrapper1.compareTo(wrapper2));//（2）

2.自动装箱和拆箱

//自动装箱 法1
Integer data1=10;
Integer data2=20;
System.out.println(data1/3);
System.out.println(data1.doubleValue()/3);
System.out.println(data2.compareTo(data2));
//自动装箱 法2
int i = 30;
Integer data3=i;
//3.14f自动装箱为Float然后指定给number
Number bumber=3.14f;
//自动装箱然后自动拆箱
Integer wrapper=10;
int foo=wrapper;
//运算时也可以自动装箱和拆箱
System.out.println(wrapper+10);
System.out.println(i++);
Boolean f=true;
System.out.println(f&&false);

　　　　　Integer number = 10;
        Integer localInterger = Integer.valueOf(100);//编译程序自动将程序代码展开
        Integer i = null;
        int j = i;
        Integer i1 = 100;
        Integer i2 = 100;
        if (i1 == i2) {
            System.out.println("i1==i2");//结果为i1==i2;
        } else {
            System.out.println("i1!=i2");
        }
        Integer i10 = 200;//值不再-128到127范围内所以会新建对象所以不是同一个参考对象。
        Integer i20 = 200;
        if (i10 == i2) {
            System.out.println("i1==i2");
        } else {
            System.out.println("i1!=i2");//结果为i1！=i2
        }

 valueOf操作

 public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

IntegerCache.low=-128;

IntegerCache.high=127;
比较对象的实质内容的值是否相同使用equals；==，！=比较的是参考对象。

三、数组对象

　　　　 int[] score = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };//静态初始化
        int[] arr = new int[10];// java数组必须给定大小，元素是自动初始化的。数组下标为0-9。//动态初始化
　　　　 int[] arr1=new int[3]{1,2,3};//动态初始化
        for (int i = 0; i < score.length; i++) {
            System.out.println(score[i]);
        }
        for (int i : score) {//增强式for循环
            System.out.println(score[i]);
        }

    int[][] scores=new int[5][5];
        for (int[] is : scores) {//增强式for循环使得更加的简洁
            for (int i : is) {
                System.out.println(i);
            }

        }

注意：1.数组变量引用了具体的数组对象；2.数组元素是自动初始化的，自动初始化为零值；3.零值包括：0（整型）、0.0（浮点型）、\u000（char）、false（Boolean）、null(引用类型)

java.util.Arrays的fill（）方法可以设定新建数组的元素值

int[] arr = new int[5];//0,0,0,0,0
Arrays.fill(arr,60);//60,60,60,60,60

数组的复制：

System.arraycopy(arr1,arr1Index,arr2,arr2tIndex,arr1.length)

int [] arr2=Arrays.copyOf(arr1,arr1.length);//jdk6以上

四、字符串对象

1.字符数组和字符串之间的转换

        String name="justin";
        System.out.println(name);
        System.out.println(name.charAt(0));
        System.out.println(name.toUpperCase());
        char[] cs={'j','u','s','t','i','n'};
        String name1=new String(cs);
        char[] cs1=name1.toCharArray();    

执行时指定命令行自变量 Java  package.class 1 2 3 4

　　　　 long sum=0;
        for (String string : args) {
            sum+=Long.parseLong(string);
        }
　　　　　System.out.println("平均："+(float)sum/args.length);

2.字符串的特性

　　1.字符串常量和字符串池

　　为了效率考虑以""包括的字符串（字符串常量），只要内容相同（序列大小写相同），无论在代码中出现几次，JVM都只会建立一个String实例，并在字符串池中维护。比较对象的内容用equals()方法

  　　   String name1="justin";
        String name2="justin";
        String name3=new String("justin");
        String name4=new String("justin");
        System.out.println(name1==name2);//true
        System.out.println(name3==name4);//false
　　　　 System.out.println(name3.equals(name4));//true

　　　2.不可变动字符串

　　　　　使用+连接字符串，会建立java.lang.StringBuilder对象，使用其append()方法来+左右两边字符串的附加，最后转换为toString()返回。所以使用+会频繁产生新对象

　　　　　会造成效能的负担。可以使用StringBuilder来改善。

　　　　性能测试如下

public static void main(String[] args) {
        System.out.println(testStringBuilder(30000));
        System.out.println(testString(30000));
}
private static long testString(int i) {
        long start=System.currentTimeMillis();
        String s="";
        for (int j = 0; j < i; j++) {
            s+="a";
        }
        long end=System.currentTimeMillis();
        return end-start;
    }

    private static long testStringBuilder(int i) {
        long start=System.currentTimeMillis();
        StringBuilder s=new StringBuilder();
        for (int j = 0; j < i; j++) {
            s.append("a");
        }
        long end=System.currentTimeMillis();
        return end-start;
    }
结果如下：

　　　　0
　　　　453

　

　　　　　StringBuilder s =new StringBuilder("123");//String->StringBuilder

　　　　　String str=s.toString();//StringBuilder->String　

String name1="java";
String name2=name1+"world";//产生新对象name2!=name4
String name3="java"+"world";//字面量和常量的运算会先运算出结果所以没有新建对象name3==name4
Stringname4="javaworld";
System.out.println(name2);
//反编译
String name1="java";
String name2=(new StringBuilder()).append(name1).append("world").toString;
//(1)
String text="";
for(int j;j<100;j++){
　　text+=j+'+'
}
//（2）
StringBuilder builder=new StringBuilder();
for(int i=1;i<100;i++)
{
　　builder.append(i).append('+');
}

字符串编码

1简体中文window下的纯文本编辑器GB2312

2.NetBeans中建立的Java原始码，默认是utf-8

3Eclipse下建立的.Java源码默认是GB2312

4.JVM在加载.class之后就会读取Unicode编码并产生对应的字符串对象，如果你是用的是utf-8编码那么编译时就要指定编码为utf-8。

( Javac -encofing UTF-8 main.java )