面向对象

面向对象的程序设计具有封装性、继承性、多态性。
类的定义语法如下：

class 类名称{数据类型 属性(变量);...public 返回值的数据类型 方法名称(参数1，参数2...){程序语句;[return 表达式;]
}
}

定义类

class Book {String title;double price;public void getlnfo() {System.out.println("图书名称:" + title + ",价格" + price);}}

声明并实例化对象

类名称 对象名称 = new 类名称();

class Book {								//定义一个类String title;double price;public void getlnfo() {				//此方法将由对象调用System.out.println("图书名称:" + title + ",价格" + price);}}
public class Test1_2 {public static void main(String args[]){Book bk = new Book();				//声明并实例化对象bk.title = "java开发";bk.price = 89.9;bk.getlnfo();						//调用类中的getlnfo()方法}
}

堆内存：
保存每一个对象的属性内容，堆内存需要用关键字new才可以开辟(可以理解为只要有关键字new，不管在何种情况下，都表示要开辟新的堆内存空间)，如果一个对象没有对应的堆内存指向，将无法使用。
栈内存：
保存的是一块堆内存的地址数据，可以把它想象成一个int型变量(每一个 int型变量只能存放一个数值)，所以每一块栈内存只能够保留一块堆内存地址。

二者关系如下：

引用传递

public class Test1_2 {public static void main(String args[]){Book bookA = new Book();Book bookB = null ;	//注意这里没有使用new实例化bookA.title = "java开发";bookA.price = 89.9;bookB=bookA;		//引用传递，相当于BookA和BookB这两个栈内存同时指向同一块堆内存bookB.price = 60;	//所以BookB修改属性内容时，会直接影响BookA对象的内容bookA.getlnfo();}
}

我将它理解为创造多个不同名称的指针来指向同一个地址。

同理，声明并实例化的对象也可以进行引用传递。

public class Test1_3 {public static void main(String args[]){Book bookA = new Book();//声明并实例化Book bookB = new Book();//声明并实例化bookA.title = "java开发";bookA.price = 89.8;bookB.title = "JSP开发";bookB.price = 69.8;bookB=BookA;//引用传递bookB.price = 100.1;bookB.getlnfo();}
}

经过引用传递后bookB原来的堆内存里面的数据就没有对象指向了，该内存空间也就成为了垃圾空间。
在java中所有的垃圾都会不定期地被垃圾收集器(GC)回收，回收后会释放掉其所占用的空间。

封装性初步分析

使用private关键字封装，将类中的属性进行私有化操作。
封装后的属性只能在该类中被访问，除非定义相应的setter、getter方法。

class Book2{private String title;private double price;public void setTitle(String t){title = t;}public void setPrice(double p){if(p>0.0){						//数据验证price = p;}}public String getTitle(){return title;}public double getPrice(){return price;}public void getInfo(){System.out.println("图书名称："+title+",价格："+price);}
}
public class Test1_4 {public static void main(String args[]){Book2 book = new Book2();book.setTitle("Java开发");book.setPrice(-89.9);book.getInfo();}
}

setter方法主要是设置内容：public void setTitle(String t)，有参；
getter方法主要是取得属性内容：public String getTitle()，无参；

构造方法

构造方法本身是一种特殊的方法，它只在新对象实例化的时候调用
定义原则：
方法名称与类名称相同，没有返回值类型声明，同时构造方法可以进行重载。

class Book3{public Book3(){				//构造方法System.out.println("**********");}
}
public class Test1_5 {public static void main(String args[]){Book3 book = null;book = new Book3();}
}

构造方法只有在使用关键字new实例化对象时才会被调用一次。

用构造方法为属性赋值

class Book3{private String title;private double price;public Book3(String t,double p){setTitle(t);setPrice(p);}public void setTitle(String t){title = t;}public void setPrice(double p){price = p;}public String getTitle(){return title;}public double getPrice(){return price;}public void getInfo(){System.out.println("图书名称："+title+",价格："+price);}
}
public class Test1_5 {public static void main(String args[]){Book3 book = new Book3("Java开发",69.8);book.getInfo();}
}

匿名对象

没有栈内存指向的堆内存空间，就是一个匿名对象。

class Book4{private String title;private double price;public Book4(String t,double p){title = t;price = p;}public void getInfo(){System.out.println("图书名称："+title+",价格："+price);}
}
public class Test1_6 {public static void main(String args[]){new Book4("Java开发",69.8).getInfo();     //匿名对象}
}

这里的匿名对象由于没有对应的栈内存指向，所以只能使用一次，一次过后就将成为垃圾，并等待GC回收释放。

简单Java类

基本开发要求：
1.类的名称必须存在意义；
2.类中所有的属性必须private封装，封装后的属性必须提供setter、getter；
3.类中可以提供任意多个构造方法，但是必须保留一个无参构造方法；
4.类中不允许出现任何输出语句，所有信息输出必须交给被调用处输出；
5.类中需要提供一个取得对象完整信息的方法，而且返回String型数据。

class Emp{private int empno;      //雇员编号private String ename;   //雇员姓名private String job;     //雇员职位private double sal;     //雇员工资private double comm;    //佣金public Emp(){           //明确一个无参构造方法}public Emp(int eno,String ena,String j,double s,double c){//有参构造empno = eno;				//为属性赋值ename = ena;job = j;sal = s;comm = c;}public void setEmpno(int e){	//设置属性内容empno = e;}public void setEname(String e){ename = e;}public void setJob(String j){job = j;}public void setSal(double s){sal = s;}public void setComm(double c){comm = c;}public int getEmpno() {			//取得属性内容return empno;}public String getEname(){return ename;}public  String getJob(){return job;}public double getSal(){return sal;}public double getComm(){return comm;}public String getInfo(){		//取得完整信息return "雇员编号："+empno+"\n"+ "雇员姓名："+ename+"\n"+"雇员职位："+job+"\n"+"基本工资："+sal+"\n"+"佣金："+comm;}
}
public class Test1_7 {public static void main(String args[]){Emp e =new Emp(7369,"SMITH","CLERK",800.0,1.0);	//实例化对象System.out.println(e.getInfo());				//取得对象信息}
}

数组

java中数组的基本概念：
数组指的就是一组相关变量的集合。

数组属于引用型数据。

声明并开辟数组：

数据类型 数组名称 [] = new 数据类型 [长度] ;
数据类型 [] 数组名称 = new 数据类型 [长度] ;

java为了方便数组的输出，提供了一个"数组名称.length"的属性，可以取得数组长度

数组动态初始化

public class Test1_8 {public static void main(String args[]){int data [] = new int [3];		//定义数组data[0] = 10;data[1] = 20;data[2] = 30;for(int x=0;x<data.length;x++){System.out.println(data[x]);}}
}

注意：不能直接使用未开辟空间的数组

数组也可以进行引用传递

public class Test1_9 {public static void main(String args[]){int data[] = new int [3];data[0] = 10;data[1] = 20;data[2] = 30;int temp[] = data;  //数组的引用传递temp[0] = 99;for(int x=0;x<data.length;x++) {System.out.println(data[x]);}}
}

数组静态初始化

格式：
1.简化形式

数据类型 数组名称 [] ={值,值,...};

2.完整形式

数据类型 数组名称 [] = new 数据类型 [] {值,值,...};

public class Test1_1_1 {public static void main(String args[]){int data[] = new int[] {1,2,3,4,5};for(int x=0;x<data.length;x++){System.out.println(data[x]);}}
}

二维数组

动态初始化：数据类型 数组名称[][] = new 数据类型[行数][列数];
静态初始化：数据类型 数组名称[][] = new 数据类型[][] {{值,...,值},{值,...,值}}

所谓的二维数组其实就是将多个一维数组变为一个大数组，并且为每个一维数组设置一个行号。

public class Test1_1_2 {public static void main(String args[]){int data[][] = new int [][]{{1,2,3},{4,5,6},{7,8,9}};for(int x=0;x<data.length;x++){for(int y=0;y<data.length;y++){System.out.print(data[x][y]+"\t");}System.out.println();}}
}

数组作为方法参数的传递

public class Test1_1_3 {public static void main(String args[]){int data[] = new int[]{1,2,3};change(data);for(int x=0;x<data.length;x++){System.out.println(data[x]);}}public static void change(int temp[]){for(int x=0;x<temp.length;x++){temp[x]=temp[x]*2;}}
}

既然有匿名对象，那当然也有匿名数组。

数组操作方法

数组复制

数组复制可以将一个数组的部分内容复制到另外一个数组之中。

System.arraycopy(数组名称,源数组复制开始索引,目标数组名称,目标数组复制开始索引,长度)

public class Test1_1_4 {public static void main(String args[]){int dataA[] = new int[]{1,2,3,4,5,6,7,8};int dataB[] = new int[]{11,22,33,44,55,66,77,88};System.arraycopy(dataA,4,dataB,2,3);print(dataB);}public static void print(int temp[]){for(int x=0;x<temp.length;x++){System.out.print(temp[x]+"、");}System.out.println();}
}
结果为：11、22、5、6、7、66、77、88、

数组排序

数组排序可以按照由小到大的顺序对基本数据类型进行排序。
其定义如下：

java.util.Arrays.sort(数组名称);

public class Test1_1_5 {public static void main(String args[]){int data[] = new int[]{3,6,1,2,8,0};java.util.Arrays.sort(data);print(data);}public static void print(int temp[]){for(int x=0;x<temp.length;x++){System.out.print(temp[x]+"、");}System.out.println();}
}