引用传递初次分

引用传递的本质在于别名，一块堆内存可以被多个栈内存所指向。

Person per1=new Person();
per1.name="小宇子"；
per1.age=30;
//此步骤就是引用传递的操作
Person per2=per1;//采用同样的类型接收
per2.name="狗剩"；//设置一个名字
per1.info();

内存关系图

Person per1=new Person();
Person per2=new Person();
per1.name="小宇子";
per1.age=30;
per2.name="张三"；
per2.age=20;
per2=per1;
per2.name="狗剩"；
per2.age=30;
per1.info();

内存关系图

在程序开发过程中，所谓的垃圾空间指的就是没有任何栈内存指向的堆内存空间，所有的垃圾空间将不定期被java垃圾收集器（GC  Garbage Collector）进行回收以实现内存空间的释放，从实际开发来讲，虽然java有GC，但是GC会降低程序的性能，所以在开发中一定要控制好对象的产生数量，即：无用的对象尽可能少产生。

1、类本身属于引用类型，所以类的使用上会牵扯到内存的分配问题。

2、所谓的类描述的就是共性的特征。任何时候只是依靠共性的特征是无法进行精准描述的，那么就需要一些个性化得特点。就可以描述一个个独立的事物。所以这样我们就可以推断出：所谓的类指的就是一个共性的概念，而对象指的是一个具体的可以使用的事物。

3、那么很明显在实际的开发过程中一定需要产生类，而后才可以产生对象。那么对象的所以操作行为都一定在类中进行了完整定义。类中没有定义的功能，那么对象一定无法使用。

类中的组成：方法（操作的行为）、属性（变量，描述每一个对象的特点）

2.2 类与对象的定义

如果在程序之中要进行类的定义你可以使用class关键字完成，而定义的语法如下：

class 类名称 { //所有的程序都要求以“{}”作为分界符

          属性；

          属性；

          方法（）{}

}

此时的方法不在由主类直接调用，而是要通过对象进行调用。

范例：定义类

class Person{
	String name;
	int age;
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}

在这个类中只是定义了两个属性和一个方法，特别需要注意的是，类中可以定义的属性数量和方法数量是没有限制的，而且在编写的时候，每一个方法中的代码尽量不要特别长。

类定义完成之后是不能够直接去使用的，如果要想使用类必须要产生对象，而对象的定义分为以下两种语法形式：

• 声明并实例化对象：类名称 对象名称 = new 类名称（）；
• 分步进行对象实例化：

• 调用类中的属性：对象.属性 = 内容；
• 调用类中的方法：对象.方法（）；

class Person{//定义一个类，类名称要求首字母大写
	String name;
	int age;
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称（）；
		Person kai = new Person();//这个时候就表示我们实例化了一个kai对象
		kai.name = "wangkai";//设置对象中的属性
		kai.age = 23;
		kai.info();//调用方法
	}
}

第一个代码模型：简单java类

现在假设有这样一个要求，定义一个雇员类，该类中会包含雇员编号，姓名，职位，基本工资，佣金几个属性信息。

那么这种类称为简单java类，既然是简单java类就有自己明确的开发要求：

• 类名称应该有意义，可以明确的描述出某一类，例如：Emp，Member，Dept；
• 类中的所有属相必须使用private封装，所有的属性必须按照要求提供setter，getter方法；
• 类中可以定义若干个构造方法，但是必须保留有一个无参构造方法；
• 类中的所有方法都不允许出现任何的System.out语句，所有的输出必须交给调用处完成。
• 类中应该提供一个返回类完整信息的方法，这个方法名称暂时为getInfo（）。

//简单java类
class Student{
	private int id;
	private String name;
	private String sex;
	private int grade;
	private double score;
	public Student(int i,String n,String s,int g,double so) {
		setId(i);
		setName(n);
		setSex(s);
		setGrade(g);
		setScore(so);
	}
	public void setId(int i) {
		id = i;
	}
	public void setName(String n) {
		name = n;
	}
	public void setSex(String s) {
		sex = s;
	}
	public void setGrade(int g) {
		grade = g;
	}
	public void setScore(double so) {
		score = so;
	}
	public int getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public String getSex() {
		return sex;
	}
	public int getGrade() {
		return grade;
	}
	public double getScore() {
		return score;
	}
	public String getInfo() {
		return "id= " + id + ",name= " + name + ",sex= " + sex + ",grade = " + grade +",score = " + score; 
	}
}
public class Class14{
	public static void main(String args[]) {
		Student kai = new Student(1,"wangkai","man",2,90.0);
		System.out.println(kai.getInfo());
	}
}

1. 以后的开发中搞得最多的就是简单java类，从基础的web开发，到分布式开发，到处都是简单java类。
2. 开发原则一定要记牢。

数组排序（一般升序）：八大排序方法

冒泡法；

private 必须要有setter getter

但是必须要包括一个无参构造方法

类中所有的方法都不允许有system.out.println语句

类中有返回完整信息的方法 ，即getinfo（）

数组反转

如果程序慢，CPU占量大。算法有问题。

空间占内存！代码有问题，浪费了内存空间。

二维数组转置：行列必须相等

二维转置：中间轴不变（x==y）

for(int x=0;x<arr.length;x++){

      for(int y=x;y<arr[x].length;y++){

          if(x!=y){

             int temp=arr[x][y];

             arr[x][y]=arr[y][x];

             arr[y][x]=arr[x][y]; 

         }

      }

}

数组查询：

遍历法；

二分法（折半查找法）（前提是数组排序）：先找数据中间点，判断当前数据在前半部分还是后半部分。，然后再判断数据在新数组的前半部分还是后半部分。

实现二分查找（方法递归查找）

public static int binarySearch (int arr[],int from, int to,int key){

if(from<to){   //循环结束条件

int mid=(from/2)+(to/2);     //确定中间节点

if(mid==key){         //如果数据找到

return mid ;            //取得当前索引

}else if (key<arr[mid]){

    return binarySearch(arr,from, mid-1,key);

}else if (key>arr[mid]){

return binarySearch( arr, mid+1,to,key)

}else{

return -1}

}//

} 

对象数组；定义为数组的对象

对象数组往往以引用类型数据定义

对象数组定义的两种格式：

对象数组动态初始化 ：

类名称 对象数组名称  []=new 类名称[长度]

对象数组静态初始化：

类名称 对象数组名称  []=new 类名称[]{ 实例化对象。。。}

动态初始化后，对象数组中的每个元素都是其对应数据类型的默认值

字符串拆分

在整个的字符串之中，可以使用一个特定的字符串来实现字符串的分割处理，也就是说可以将一个完整的字符串，按照指定的分隔符划分为若干个子字符串：

public String[] sqlit(String regex)

将字符串全部拆分

public String[] sqlit(String regex,int limit)

将字符串部分拆分，该数组长度就是limit长度的极限

范例：实现字符串的拆分处理

String str = "hello world hello mldn";

String result [] = str.split(" ");//按照空格拆分

for(int x = 0;x< result.length;x++){

System.out.println(result[x]);

}

范例：部分拆分

String str = "hello world hello mldn";

String result [] = str.split(" " , 2);/按照空格进行拆分，将字符串拆分为两段

for(int x = 0; x < result.length;x++){

System.out.println(result[x]);

}

已上的拆分形式都很容易，如果发现有些内容无法拆分开，就需要使用“\\”进行转义

范例：拆分ip地址

String str = "192.168.1.1";

String result [] = str.split("\\. " );/使用转义字符，才可拆分

for(int x = 0; x < result.length;x++){

System.out.println(result[x]);

}

在以后的实际开发之中，经常会出现这样的拆分模式：姓名：年龄|姓名：年龄|....

范例：

String str = "SMITH:10|ALLEN:20";

String result [] = str.split("\\|" );/使用转义字符，才可拆分

for(int x = 0; x < result.length;x++){

String temp [] = result[x].split(":");

System.out.println(temp[0] + "=" + temp[1]);

}

这个代码在以后的开发中会经常出现。

string类对象实例化：

1：直接赋值实例化对象

2：

string类能不能使用"=="?

“==”比较的是数值

如果str1余str2进行==；比较的是物理地址比较

内容比较用  equals();

所以string内容比较用的是  equals()方法

字符串截取

从一个完整的字符串之中截取出部分内容，那么对于截取的方法，如下：

public String substring(int beginIndex)

从指定索引索引截取到最后

public String substring(int beginIndex,int endIndex)

截取部分内容：

范例：观察字符串的截取操作

String str = "helloworld";

System.out.println(str.substring(5));

System.out.println(str.substring(0,5));

千万记住了，程序中的字符串截取索引从0开始，而且只能设置正整数，不能使用负数。

字符串常量，是string类的匿名对象

日后开发过程中，如果要判断用户输入的字符串是否等于指定的字符串时，一定将指定字符串写在前面。。而不能将用户输入的字符串写在前面，因为要考虑用户没有输入内容的情况，这种情况，字符串为null，此时会出现空指针错误

比较操作的方法一：

数据接收的时候，要考虑用户没有输入数据的情况。

string  str= new string ("hello");

会产生堆内存垃圾空间，且没有保存到string对象池中。

如何将其保存到对象池中？

string str= new string ("hello").intern( );

字符串两种实例化的区别：

直接赋值：只开辟一块堆内存，而且内容保存在对象池中，以供下次使用。

构造方法：会开辟两块堆内存，并产生垃圾堆空间，而且不能直接保存在对象池中

getNode 代码错误

应该是

if

...

else

return this.next.getNode(index)

字符串的使用 就采用直接复制的模式完成

字符串内容比较，采用equals()方法实现

字符串最好不要频繁改变

如下代码不该出现；

str+="hello"

字符串不适合频繁修改，否则会出现大量内存垃圾。

string类方法必须背下来！！！

（成员）field

（构造方法）constructor

（普通方法）Method

类定义：

1.声明并实例化对象：类名称 对象名称=new 类名称（）;

2.分步进行对象实例化：

(1)声明对象：类名称  对象名称=null;

(2)实例化对象：对象名称=new 类名称();

调用类中的属性：对象.属性=内容;

调用类中的方法：对象.方法();

支持字符串与字符数组相互转换

字符串转字符数组：  str.toCharArray();

字符数组转字符串： new string（字符数组）

部分转换： new string （字符数组，起始index，长度）

如果返回值为boolean的，方法命名一般用is**命名

学习正则表达式！