链表
来源：互联网 发布：农村淘宝现状分析 编辑：程序博客网 时间：2024/06/05 14:42
2、知识点
2.1、上次课程的主要知识点
1、 String类的特点：
· 两种初始化方式：
|- 第一种：直接赋值，只开辟一个空间，所有的内容都放在字符串对象池之中，以后如果定义了相同内容，则不会重新开辟新的空间；
|- 第二种：通过关键字new，开辟两个空间，使用intern()方法可以让一个字符串归入池中；
· 一个字符串就是String的匿名对象；
· 字符串比较有两种方式：==（比较地址数值）、equals()（比较字符串内容）
· 字符串一旦声明则不可改变，改变的是内存地址的指向。
2、 String类的方法：charAt()、indexOf()、contains()、compareTo()、replaceAll()、substring()、split()、toUpperCase()、toLowerCase()、toCharArray()、getBytes()、isEmpty()、startsWith()、endsWith()、trim()、length()
3、 面向对象的三大特征：封装、继承、多态；
Java本身是面向对象语言，但是最早的面向对象语言是smalltalk（IBM），后来才有了C++。
4、 类与对象的关系：
· 类：对现实世界的一种抽象方法，由属性及方法所组成；
· 对象：是类的具体应用，类只有通过对象才可以使用，对象的所有操作行为由类决定；
· 对象的引用传递及内存分配；
5、 封装性：通过private关键字完成，而且也强调了在Java的类中只要是属性就要求进行封装，所有封装的属性只能通过setter和getter设置和取得；
6、 构造方法：
· 构造方法的名称要求与类名称保持一致；
· 构造方法没有返回值类型的声明，也不可以使用void；
· 在通过关键字new实例化一个类对象的时候，会自动调用类中的构造方法；
· 每个类中至少存在一个构造方法，如果一个类没有明确的声明一个构造方法的话，则会自动生成一个无参的，什么都不做的构造方法；
· 构造方法允许重载，但是在进行构造方法重载的时候建议一定要将参数少的构造方法写在前面；
7、 this关键字：
· this可以调用本类中的属性，this.属性，而且也强调过，以后只要是调用属性永远加上this；
· this可以调用本类中的方法，包括普通方法及构造方法，但是使用this()调用构造方法的时候必须放在构造方法的首行，而且如果一个类中有多个构造方法的话，则至少有一个构造方法是不使用this()调用的情况；
· 以上的所有特点实际上都可以理解为：this表示当前对象，当前调用类中方法的对象就是当前对象。
2.2、本次预计讲解的知识点
1、 引用传递的深入研究；
2、 链表的基本实现（难点）；
3、 对象数组的基本概念及使用；
4、 static关键字的使用。
3、具体内容
3.1、深入引用传递（重点）
引用传递为整个JAVA的核心部分，在实际的开发之中肯定要多次使用，而且也作为重点必须掌握，下面通过一些实际的范例强调一下引用传递的使用。
3.1.1、三道引用传递分析
为了更好的说明问题，下面给出三道题目，要求可以独立的分析出最终的运行结果。
范例：第一道范例
class Demo {
private int count = 10 ;
public void setCount(int count){
this.count = count ;
}
public int getCount(){
return this.count ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Demo d = new Demo() ;
d.setCount(100) ;
fun(d) ;
System.out.println(d.getCount()) ;
}
public static void fun(Demo temp){
temp.setCount(30) ;
}
};
下面通过内存关系图来分析本程序的运行结果。
范例：第二道范例
public class OODemo { // 第二个类
public static void main(String args[]){
String str = "Hello" ;
fun(str) ;
System.out.println(str) ;
}
public static void fun(String s){
s = "World" ;
}
};
分析的关键点：字符串的内容一旦声明则不可改变，改变的是其内存地址的指向。
因为字符串的内容不可改变，所以在方法之中修改的“World”根本就不会被保留下来，而原本的“Hello”并没有任何的变化。
范例：第三道范例
class Demo {
private String info = "Hello" ;
public void setInfo(String info){
this.info = info ;
}
public String getInfo(){
return this.info ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Demo d = new Demo() ;
d.setInfo("World") ;
fun(d) ;
System.out.println(d.getInfo()) ;
}
public static void fun(Demo temp){
temp.setInfo("!!!") ;
}
};
本程序实际上与第一道程序没有区别，下面同样通过内存关系图来划分。
这三道程序实际上只是分为两组：
· 第一道和第三道程序：就好比一个背包一样
· 第二道程序：就好比一个直接的馒头
这三道程序的主要目的是为了理解字符串及引用传递的一个简单的问题分析，在程序中记住了，如果现在传的是一个类，则类中的属性的修改是可以被保留下来的，但是String虽然是一个类，可是在进行引用传递的时候最好将其理解为一个普通的数字。
3.1.2、实际问题
一个人有一辆小汽车，那么此种关系应该怎样表示呢？
人应该属于一个类，车也应该属于一个类。
class Person {
private String name ;
private int age ;
private Car car ; // 一个人有一辆车
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
public void setCar(Car car){ // 为一个人配一辆车
this.car = car ;
}
public Car getCar(){ // 通过人可以找到他的车
return this.car ;
}
};
class Car {
private String name ;
private Person person ;
public Car(String name){
this.name = name ;
}
public String getInfo(){
return "车的名字：" + this.name ;
}
public void setPerson(Person person){
this.person = person ;
}
public Person getPerson(){
return this.person ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Person per = new Person("张三",30) ;
Car car = new Car("BMW 5X") ;
per.setCar(car) ; // 一个人有一辆车
car.setPerson(per) ; // 一辆车属于一个人
System.out.println(per.getInfo() + per.getCar().getInfo()) ;
}
};
问题：一个人长大之后肯定要有孩子，每个孩子依然还要辆车。
class Person {
private String name ;
private int age ;
private Car car ; // 一个人有一辆车
private Person child ; // 表示一个孩子
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
public void setCar(Car car){ // 为一个人配一辆车
this.car = car ;
}
public void setChild(Person child){
this.child = child ;
}
public Person getChild(){
return this.child ;
}
public Car getCar(){ // 通过人可以找到他的车
return this.car ;
}
};
class Car {
private String name ;
private Person person ;
public Car(String name){
this.name = name ;
}
public String getInfo(){
return "车的名字：" + this.name ;
}
public void setPerson(Person person){
this.person = person ;
}
public Person getPerson(){
return this.person ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Person per = new Person("张三",30) ;
Person chd = new Person("张四",18) ;
Car car = new Car("BMW 5X") ;
Car c = new Car("自行车") ;
per.setCar(car) ; // 一个人有一辆车
car.setPerson(per) ; // 一辆车属于一个人
chd.setCar(c) ; // 一个孩子有一辆车
c.setPerson(chd) ; // 这辆车属于一个孩子
per.setChild(chd) ; // 一个人有一个孩子
System.out.println(per.getInfo() + per.getCar().getInfo()) ;
// 代码链对象.方法().方法().方法().....
System.out.println(per.getChild().getInfo() + "，" + per.getChild().getCar().getInfo()) ;
}
};
掌握了此方法之后，现实世界之中的很多关系都可以表示了：
· 一个人有一间房子；
· 一个人有一台电脑；
· 一个人有一个原配妻子；
3.2、对象比较（重点）
在JAVA之中，有一种程序是比较难用语言描述出来的概念，在正常情况下，一个在类外部的对象不能操作类本身的私有属性，但是如果现在将一个类的对象放回到类本身之中，则可以直接操作，但是这种做法只有在一个地方上使用。
范例：接收本类的引用
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
public void set(Person p){
p.name = "李四" ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Person per = new Person("张三",20) ;
per.set(per) ;
System.out.println(per.getInfo()) ;
}
};
之所以要讲本类用法，主要是为以下的一个要求服务。
范例：现在有两个Person对象，如何可以判断这两个对象是否相等呢？
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Person per1 = new Person("张三",20) ;
Person per2 = new Person("张三",20) ;
if(per1.getName().equals(per2.getName()) && per1.getAge()==per2.getAge()){
System.out.println("是同一个人！") ;
} else {
System.out.println("不是同一个人！") ;
}
}
};
现在已经实现了对象的比较操作，但是这种代码存在问题？
1、 每次的比较都要写此代码；
2、 要是属性多了肯定还得这么比；
3、 main()方法是一个客户端代码，客户端的操作越少越好；
4、 对于这种比较的操作，应该是类本身所具备的功能，每个对象都应该直接提供此操作，而不应该交给第三方完成功能。
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public boolean compare(Person p){
if(this == p){ // 两个对象的地址相等
return true ; // 肯定相等
}
if(p == null){
return false ;
}
if(this.name.equals(p.name) && this.age==p.age){
return true ;
} else {
return false ;
}
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Person per1 = new Person("张三",20) ;
Person per2 = new Person("张三",20) ;
if(per1.compare(per2)){
System.out.println("是同一个人！") ;
} else {
System.out.println("不是同一个人！") ;
}
}
};
本程序是在开发中唯一接收本类对象有意义的程序，那么说到这里，忽然又想到另外一个根本就没有意义的程序，来分析一下本程序的操作。
class A {
public A(){
new B(this).fun() ;
}
public void print(){
System.out.println("Hello World !!!") ;
}
};
class B {
private A a ;
public B(A a){
this.a = a ;
}
public void fun(){
this.a.print() ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
new A() ;
}
};
程序中构造方法的this表示的就是new A() ;这个在主方法中实例化的对象，
3.3、链表（理解）
链表操作是数据结构的一种体现，也是一种最简单的数据结构。
链表实际上是一种数据的载体体现
如果现在将每一个人当作一个节点来看的话，则每一个节点要保存当前的数据，以及下一个节点。
class Node {
private String data ;
private Node next ;
};
以后如果有数据则直接向data中保存，而且每一个新增加的节点都要放在当前节点之后。
在链表操作之中，第一个节点肯定就是根节点。
class Node {
private String data ;
private Node next ;
public Node(String data){
this.data = data ;
}
public void setNext(Node next){
this.next = next ;
}
public String getData(){
return this.data ;
}
public Node getNext(){
return this.next ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Node root = new Node("根节点") ;
Node n1 = new Node("第一个节点") ;
Node n2 = new Node("第二个节点") ;
Node n3 = new Node("第三个节点") ;
root.setNext(n1) ; // 根节点和第一个节点的关系
n1.setNext(n2) ; // 第二个节和第一个节点的关系
n2.setNext(n3) ;
print(root) ; // 从根节点开始输出
}
public static void print(Node node){
System.out.println(node.getData()) ;
if(node.getNext() != null){ // 还有下一个节点
print(node.getNext()) ; // 继续输出下一个节点
}
}
};
以上是一个链表实现的基本模型，但是在这个操作模型之中，可以发现所有的内容都是手工设置的，这样肯定不合适，就好比小孩排队一样，当挑选出来一个孩子之后，跟他说，孩子去排队。
在这种情况下，这种手工完成的链表设置实在是太麻烦了，所以应该使用一种自动的方式完成，即：每一个新的数据如果要想保存进来之后，应该有一个操作类，帮助用户将此新的数据排放到整个链表的最后一个位置。
现在增加一个新节点的根本原因在于：当前节点没有下一个节点的时候，就将新节点保存。
class Node {
private String data ;
private Node next ;
public Node(String data){
this.data = data ;
}
public void setNext(Node next){
this.next = next ;
}
public String getData(){
return this.data ;
}
public Node getNext(){
return this.next ;
}
public void addNode(Node newNode){ // 增加新节点
if(this.next == null){ // 当前节点没有下一个节点
this.next = newNode ; // 保存新节点
} else {
this.next.addNode(newNode) ;
}
}
public void printNode(){
System.out.println(this.data) ; // 输出当前节点内容
if(this.next != null){ // 当前节点之后还有节点
this.next.printNode() ;
}
}
};
class Link { // 完成链表的操作类
private Node root ; // 表示根节点
public void add(String data){ // 增加数据
Node newNode = new Node(data) ; // 新的节点
if(this.root == null){ // 现在还没有根节点，则应该将新的节点作为根节点
this.root = newNode ; // 第一个节点作为根节点
} else { // 该放到那里就放到那里去
this.root.addNode(newNode) ;
}
}
public void print(){
if(this.root != null){ // 这个队有人了
this.root.printNode() ;
}
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Link link = new Link() ;
link.add("A") ;
link.add("B") ;
link.add("C") ;
link.print() ;
}
};
如果现在需要查询某个节点是否存在呢？
public boolean search(String data){ // 检查指定的内容是否存在
if(this.root != null){
return this.root.searchNode(data) ; // 交给Node去做
}
return false ; // 没有内容，肯定找不到
}
public boolean searchNode(String data){ // 查找数据是否存在
if(data.equals(this.data)){ // 与当前节点数据一样，表示查找到了
return true ;
} else {
if(this.next != null){ // 当前节点存在下一个节点
return this.next.searchNode(data) ;
}
}
return false ; // 没有任何一个节点符合要求
}
既然现在已经可以查找了，那么如果要想删除一个节点呢？
public void delete(String data){
if(this.search(data)){ // 可以找到，则可以删除
if(this.root.getData().equals(data)){ // 根节点满足要求
this.root = this.root.getNext() ; // 根节点的下一个为新的根节点
} else {
this.root.getNext().deleteNode(this.root,data) ;
}
}
}
public void deleteNode(Node previous ,String data){
if(this.data.equals(data)){
previous.next = this.next ;
} else {
if(this.next != null){ // 还有下一个节点
this.next.deleteNode(this,data) ;
}
}
}
本代码无论现在隔多少个节点都可以删除掉，因为是采用逐步判断的操作，当然，如果有重复的，每次只能删除一个。
这种链表程序属于单向链表：
class Node {
private String data ;
private Node next ;
public Node(String data){
this.data = data ;
}
public void setNext(Node next){
this.next = next ;
}
public String getData(){
return this.data ;
}
public Node getNext(){
return this.next ;
}
public void addNode(Node newNode){
if(this.next == null){
this.next = newNode ;
} else {
this.next.addNode(newNode) ;
}
}
public void printNode(){
System.out.println(this.data) ;
if(this.next!=null){
this.next.printNode() ;
}
}
public boolean searchNode(String data){ // 查找数据是否存在
if(data.equals(this.data)){ // 与当前节点数据一样，表示查找到了
return true ;
} else {
if(this.next != null){ // 当前节点存在下一个节点
return this.next.searchNode(data) ;
}
}
return false ; // 没有任何一个节点符合要求
}
public void deleteNode(Node previous ,String data){
if(this.data.equals(data)){
previous.next = this.next ;
} else {
if(this.next != null){ // 还有下一个节点
this.next.deleteNode(this,data) ;
}
}
}
};
class Link { // 这是一个专门进行链表的操作类
private Node root ; // 所有的数据结构前提必须有一个根
public void add(String data){ // 将数据保存
Node newNode = new Node(data) ;
if(this.root == null){
this.root = newNode ;
} else {
this.root.addNode(newNode) ;
}
}
public void print(){
if(this.root != null){
this.root.printNode() ;
}
}
public boolean search(String data){ // 检查指定的内容是否存在
if(this.root != null){
return this.root.searchNode(data) ; // 交给Node去做
}
return false ; // 没有内容，肯定找不到
}
public void delete(String data){
if(this.search(data)){ // 可以找到，则可以删除
if(this.root.getData().equals(data)){ // 根节点满足要求
this.root = this.root.getNext() ; // 根节点的下一个为新的根节点
} else {
this.root.getNext().deleteNode(this.root,data) ;
}
}
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Link link = new Link() ;
link.add("A") ;
link.add("B") ;
link.add("C") ;
System.out.println(link.search("B")) ;
System.out.println(link.search("X")) ;
System.out.println(link.search("A")) ;
link.delete("B") ;
link.delete("A") ;
link.delete("C") ;
link.print() ;
}
};
如果现在向完成循环链表，则意味着现在所有的数据都将形成一个圈。
class Node {
private String data ;
private Node next ;
private boolean rootFlag = false ;
public Node(String data){
this.data = data ;
}
public void setNext(Node next){
this.next = next ;
}
public void setRootFlag(boolean rootFlag){
this.rootFlag = rootFlag ;
}
public boolean getRootFlag(){
return this.rootFlag ;
}
public String getData(){
return this.data ;
}
public Node getNext(){
return this.next ;
}
public void addNode(Node root,Node newNode){
if(this.next!=null) {
if(this.next.rootFlag == true){ // 当前的下一个是根节点
this.next = newNode ;
newNode = root ;
} else {
this.next.addNode(root,newNode) ;
}
} else {
this.next = newNode ; // 如果下一个为空，则表示是第一个节点
newNode.next = root ;
}
}
public void printNode(){
System.out.println(this.data) ;
if(this.next != null){
if(this.next.rootFlag == false){ // 不是根
this.next.printNode() ;
}
}
}
};
class Link { // 这是一个专门进行链表的操作类
private Node root ; // 所有的数据结构前提必须有一个根
public void add(String data){
Node newNode = new Node(data) ; // 新节点
if(this.root == null){
this.root = newNode ;
this.root.setRootFlag(true) ; // 设置根节点
} else {
this.root.addNode(this.root,newNode) ;
}
}
public void print(){
if(this.root != null){ // 有根节点
this.root.printNode() ;
}
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Link link = new Link() ;
link.add("A") ;
link.add("B") ;
link.add("C") ;
link.add("D") ;
link.print() ;
}
};
还可以实现双向链表，每个节点知道自己的下一个节点，同时也知道自己的上一个节点。
3.4、对象数组（重点）
数组之前已经强调了，是一组相关变量的集合，那么所谓的对象数组就是数组中的每个元素都是对象，在Java中对象数组的定义格式如下：
类名称 对象数组名称[] = new 类名称[数组长度] ;
表示声明并为数组开辟空间，但是这种开辟的语法属于动态初始化，则数组中的每个元素的内容都是null。
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Person per[] = new Person[3] ; // 定义数组，一共有三个元素
for(int x=0;x<per.length;x++){
System.out.println(per[x]) ;
}
}
};
现在由于每个元素都没有进行各自的实例化操作，所以数组中的每个元素都是null，那么所以对象数组中的每一个元素都必须分别进行实例化操作。
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Person per[] = new Person[3] ; // 定义数组，一共有三个元素
per[0] = new Person("张三",10) ;
per[1] = new Person("李四",12) ;
per[2] = new Person("王五",13) ;
for(int x=0;x<per.length;x++){
System.out.println(per[x].getInfo()) ;
}
}
};
数组本身是存在静态和动态初始化的，所以现在也可以通过静态初始化的方式完成对象数组的定义。
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Person per[] = {new Person("张三",10),
new Person("李四",12),new Person("王五",13)} ;
for(int x=0;x<per.length;x++){
System.out.println(per[x].getInfo()) ;
}
}
};
对象数组本身确实可以保存多个对象，但是其本身的缺点也是有的：就是数组本身永远会受到长度的限制，所以如果现在希望将代码的操作更加容易的话，往往可以通过链表完成操作。
3.5、JDK 1.5的新功能（理解）
JAVA除了JDK 1.0之外还有两个重要的版本：JDK 1.2、JDK 1.5（JAVA SE 5.0 Tiger），在JDK 1.5之中增加了许多的新特性，但是这些新特性并没有被广泛的应用在现代的开发之中。
3.5.1、可变参数
在正常情况下，一个方法之中规定的参数格式就是在调用此方法时必须传入的参数个数。
public class OODemo { // 第二个类
public static void main(String args[]){
fun(10,20) ;
}
public static void fun(int x,int y){
System.out.println(x) ;
System.out.println(y) ;
}
};
但是，在JDK 1.5之后，为了方便用户的操作，JAVA专门对参数的接收上提供了一种称为可变参数的定义格式，在调用方法的时候可以传递参数也可以传递数组或者是不传递参数，那么这些参数接收的时候实际上都是按照数组的形式接收的。
public class OODemo { // 第二个类
public static void main(String args[]){
System.out.print("没有参数：") ;
fun() ;
System.out.print("\n有一个参数：") ;
fun(10) ;
System.out.print("\n有多个参数：") ;
fun(10,20,30,40,50,60,70) ;
System.out.print("\n数组：") ;
fun(new int[]{10,20,30}) ;
}
public static void fun(int ... arg){
for(int x=0;x<arg.length;x++){
System.out.print(arg[x] + "、") ;
}
}
};
同样，既然可以传递普通数据，也可以传递对象。
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
fun(new Person[]{new Person("张三",20),new Person("李四",20)}) ;
}
public static void fun(Person ... arg){
for(int x=0;x<arg.length;x++){
System.out.println(arg[x].getInfo()) ;
}
}
};
3.5.2、foreach输出
for循环本身是JAVA所支持的一种循环的输出，但是在JDK 1.5之后，JAVA向C#学习了foreach输出的格式，改善了原本的for的输出形式
public class OODemo { // 第二个类
public static void main(String args[]){
fun(new Person[]{new Person("张三",20),new Person("李四",20)}) ;
}
public static void fun(Person ... arg){
for(Person p : arg){
System.out.println(p.getInfo()) ;
}
}
};
但是，以上的新功能知道即可，别用。
3.6、static关键字（重点）
3.6.1、static关键字的作用
static关键字本身之前已经见过了，使用static可以声明属性也可以声明方法，那么为什么要有static属性的概念呢？为了解释这个问题，下面先来观察以下的一段程序：
class BeiJingRen {
private String name ;
private int age ;
private String city = "北京" ;
public BeiJingRen(String name,int age){
this.name = name ;
this.age = age ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age + "，城市：" + city ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
BeiJingRen bjr1 = new BeiJingRen("张三",10) ;
BeiJingRen bjr2 = new BeiJingRen("李四",11) ;
BeiJingRen bjr3 = new BeiJingRen("王五",12) ;
System.out.println(bjr1.getInfo()) ;
System.out.println(bjr2.getInfo()) ;
System.out.println(bjr3.getInfo()) ;
}
};
本程序，如果画成内存关系图：
如果现在假设北京这座城市的名字改成了最早的北平，而且现在已经有了500000个对象产生了，则此时要修改500000个对象的city属性，而且如果按照这种定义格式的话也会存在问题，city属性现在是重复的，那么这个时候就发现，city应该定义成一个公共属性最合适，所以就可以通过static定义完成。
class BeiJingRen {
private String name ;
private int age ;
static String city = "北京" ;
public BeiJingRen(String name,int age){
this.name = name ;
this.age = age ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age + "，城市：" + city ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
BeiJingRen bjr1 = new BeiJingRen("张三",10) ;
BeiJingRen bjr2 = new BeiJingRen("李四",11) ;
BeiJingRen bjr3 = new BeiJingRen("王五",12) ;
System.out.println("======== city修改之前 ==========") ;
System.out.println(bjr1.getInfo()) ;
System.out.println(bjr2.getInfo()) ;
System.out.println(bjr3.getInfo()) ;
System.out.println("======== city修改之后 ==========") ;
bjr1.city = "北平" ;
System.out.println(bjr1.getInfo()) ;
System.out.println(bjr2.getInfo()) ;
System.out.println(bjr3.getInfo()) ;
}
};
现在发现，如果修改了一个对象中的city属性（city属性使用了static关键字声明）则所有对象的city内容都变了。
现在每一个对象都占有着各自的name和age属性，但是对于公共的city属性是所有对象所共同拥有的，很明显，现在如果一个对象将city属性修改了，其他的所有对象都将改变，但是这个时候又有一个问题了，既然static声明的属性是公共属性的话，那么你认为一个对象就修改了，这样合适吗？
这些所有的对象最大的头是类，所以一般调用static属性都会通过类直接调用，使用“类.static属性”的格式完成。
BeiJingRen.city = "北平" ;
既然static声明的属性可以被类名称直接调用，所以在一些书中也称其为“类属性”。
既然可以使用static声明属性，那么也就可以使用static声明方法，而且使用static声明的方法可以直接由类名称调用。
class BeiJingRen {
private String name ;
private int age ;
private static String city = "北京" ;
public BeiJingRen(String name,int age){
this.name = name ;
this.age = age ;
}
public static void setCity(String c){
city = c ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age + "，城市：" + city ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
BeiJingRen bjr1 = new BeiJingRen("张三",10) ;
BeiJingRen bjr2 = new BeiJingRen("李四",11) ;
BeiJingRen bjr3 = new BeiJingRen("王五",12) ;
System.out.println("======== city修改之前 ==========") ;
System.out.println(bjr1.getInfo()) ;
System.out.println(bjr2.getInfo()) ;
System.out.println(bjr3.getInfo()) ;
System.out.println("======== city修改之后 ==========") ;
BeiJingRen.setCity("北平") ;
System.out.println(bjr1.getInfo()) ;
System.out.println(bjr2.getInfo()) ;
System.out.println(bjr3.getInfo()) ;
}
};
但是必须提醒的是，对于static属性或方法的调用上，不一定非要使用类，但是为了保证代码的编写质量，往往都会通过类名称调用。
而且现在的类中已经存在了static方法，那么此时与非static操作之间就存在问题了：
· 非static的方法可以调用static的属性或方法；
· static的方法只能调用static的属性或方法。
为什么要存在这样的限制？
由于static的所定义的操作可以直接由类名称调用，那么也就可以在没有一个实例化对象产生的时候完成static属性或方法的调用，而所有的非static操作要求必须有实例化对象的时候才可以调用。
解释：关于之前方法定义的问题
在之前强调过，如果一个方法在主类中定义（有main()方法的类）直接调用的话，则必须使用以下的格式：
public static 返回值类型 方法名称(参数){
[return 返回值] ;
}
下面来观察，如果现在在定义的时候没有写出static会如何：
public class OODemo { // 第二个类
public static void main(String args[]){
print() ;
}
public void print(){
System.out.println("Hello World!!!") ;
}
};
如果不使用static声明，则现在的情况是static的方法调用非static的操作，按照之前所讲，肯定是错误的，那么如果现在非要调用print()方法的话呢，则只能实例化本类对象，并完成调用。
public class OODemo { // 第二个类
public static void main(String args[]){
new OODemo().print() ;
}
public void print(){
System.out.println("Hello World!!!") ;
}
};
3.6.2、static的使用
static属性本身属于公共的操作，所以在开发之中可以利用static统计出一个类产生了多少个新的实例化对象，每个对象实例化的时候都要调用类中的构造方法，所以这种统计的操作可以直接在构造方法之中完成。
class Person {
private static int count = 0 ;
public Person(){
System.out.println("第" + ++count + "个对象产生。") ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
new Person() ;
new Person() ;
new Person() ;
}
};
如果现在将此操作简单修改的话，也可以完成属性的自动命名操作。
例如：一个类之中存在一个name的属性，而且此类有两个构造方法，一个构造方法可以专门传入name属性的内容，另外一个构造方法不接收任何参数，如果用户现在调用的是不接收任何参数的构造方法的话，则按照“匿名-X”的形式保存，其中X就表示一个数字。
class Person {
private String name ;
private static int count = 0 ;
public Person(){
this("匿名 - " + count++) ; // 自动命名
}
public Person(String name){
this.name = name ;
}
public String getName(){
return this.name ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
System.out.println(new Person().getName()) ;
System.out.println(new Person("张三").getName()) ;
System.out.println(new Person().getName()) ;
System.out.println(new Person("李四").getName()) ;
System.out.println(new Person().getName()) ;
}
};
3.6.3、主方法组成
主方法一直在使用，那么这里面有很多个关键字所组成：
public static void main(String args[])，这些关键字的意义如下：
· public：表示一个访问权限，是最大的访问权限，所有用户都可以访问；
· static：表示此方法可以直接由类名称完成调用；
· void：表示主方法是一切操作的起点，没得后悔；
· main()：系统规定好的方法名称，只要是通过java命令运行，则肯定找到此方法；
· args：表示所有程序运行时接收的参数，以数组的形式返回。
所有的运行参数，都直接通过java 类名称 参数1 参数2 参数3 …的形式传递进来。
public class OODemo { // 第二个类
public static void main(String args[]){
for(int x=0;x<args.length;x++){
System.out.println(args[x]) ;
}
}
};
但是这个时候又出现了一个新的问题了，如果现在输入的参数之中本身就有空格怎么办，则此时就需要使用“"”将每个参数括起来：java OODemo "hello world" "hello mldn"
3.7、思考题
现在要求完成一个用户的登陆程序，通过初始化参数，输入登陆的用户名和密码
例如：java LoginDemo 用户名 密码
如果用户名是hello，密码是mldn的话，则表示登陆成功，显示登陆欢迎的信息，如果登陆失败，则显示登陆失败的信息。
自己思考如何做，先完成基本功能，之后再进行结构的修改。
本程序算是一个比较综合性的程序，主要的功能是理解类的设计问题，但是在实际的项目开发中一定要给一个建议：一定要先完成一些基本功能，之后再做所谓的优化。
一定要先完成基本的开发模型，之后进行代码的修改。
基本功能就是接收参数，并进行验证。
public class OODemo { // 第二个类
public static void main(String args[]){
String name = args[0] ; // 第一个参数
String password = args[1] ; // 第二个参数
if("hello".equals(name) && "mldn".equals(password)){
System.out.println("用户登陆成功！") ;
} else {
System.out.println("用户登陆失败！") ;
}
}
};
现在基本功能实现了，但是这种代码不好，主方法是一个客户端，主方法中的代码越少越好。
思考：现实世界中的登陆流程
第一步：确定所要传入的数据是否正确
第二步：将信息传入到一个接收端进行数据的采集
第三步：验证数据是否合法
首先应该有一个专门负责数据验证的操作类。
class User {
private String name ;
private String password ;
public User(String name,String password){
this.name = name ;
this.password = password ;
}
public boolean validate(){
if("hello".equals(this.name) && "mldn".equals(this.password)){
return true ;
} else {
return false ;
}
}
};
class Login { // 一个专门的操作窗口
private String args[] ;
public Login(String args[]){
this.args = args ; // 接收所有的参数
this.isExit() ; // 判断参数是否合法
}
public void isExit(){ // 如果接收的参数个数有错误，则意味着程序应该退出
if(this.args.length != 2){ // 参数的长度错误
System.out.println("错误：传入了非法的参数。") ;
System.exit(1) ; // 退出系统
}
}
public String getMsg(){
if(new User(this.args[0],this.args[1]).validate()){
return "用户登陆成功！" ;
} else {
return "用户登陆失败！" ;
}
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
System.out.println(new Login(args).getMsg()) ;
}
};
到底类该怎么设计呢？
数据库的表设计没有标准的设计方法，只有相对合理的设计，那么类设计本身也是一样的，就记住一点：一个类完成一个具体的功能，例如：如果设计的是一个表示手的类，就应该完成手的功能，而不应该将嘴的功能写在手的功能之中。
3.8、代码块（理解）
在Java程序之中，使用“{}”括起来的一段代码称为代码块，但是根据其所在的位置不同或者是声明的关键字的不同，代码块的作用也不同，代码块一共分为四种：普通代码块、构造块、静态块、同步代码块。
3.8.1、普通代码块
普通代码块是指定义在一个方法之中代码块。
public class OODemo { // 第二个类
public static void main(String args[]){
{ // 普通代码块
int x = 10 ; // 局部变量
System.out.println("x = " + x) ;
}
int x = 100 ;
System.out.println("x = " + x) ;
}
};
3.8.2、构造块
当在一个类之中直接定义一个代码块的时候，这种代码块就称为构造块。
class Demo {
{ // 构造块
System.out.println("构造块。") ;
}
public Demo(){
System.out.println("构造方法。") ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
new Demo() ;
new Demo() ;
}
};
构造块依然在对象实例化的时候进行调用，而且构造块优先于构造方法执行，每次有新的对象产生了，都将重复调用构造块中的内容。
3.8.3、静态块
在构造块的基础之上增加static关键字的声明，就表示是一个静态块了。
class Demo {
static{ // 静态块
System.out.println("****** 静态块。。。") ;
}
{ // 构造块
System.out.println("构造块。") ;
}
public Demo(){
System.out.println("构造方法。") ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
new Demo() ;
new Demo() ;
}
};
静态块是最优先执行的，而且不管实例化多少次对象，最终也只调用一次，静态块的主要功能是用于为静态属性初始化的，但是，如果现在是在主类中定义了静态块的话，则会优先于主方法执行。
class Demo {
static{ // 静态块
System.out.println("****** 静态块。。。") ;
}
{ // 构造块
System.out.println("构造块。") ;
}
public Demo(){
System.out.println("构造方法。") ;
}
};
public class OODemo { // 第二个类
static {
System.out.println("主类中的静态块。") ;
}
public static void main(String args[]){
new Demo() ;
new Demo() ;
}
};
既然静态块本身优先于主方法执行，所以这个时候就可以通过代码让一个静态块来替代掉主方法的功能。
public class OODemo { // 第二个类
static {
System.out.println("Hello World!!!") ;
System.exit(1) ;
}
};
这种代码只是娱乐，没有任何的实际意义。
3.9、内部类（重点）
内部类是JAVA的一大重点，这个重点的兴起是由于框架技术的兴起。
3.9.1、内部类的基本概念
实际上所谓的内部类就是指一个类的内部还有另外的类存在，一个类可以定义多个内部类。
class 外部类{
class 内部类{}
}
范例：定义一个简单的内部类
class Outer {
private String info = "HELLO WORLD" ; // 外部类的私有属性
class Inner { // 内部类
public void print(){
System.out.println(info) ; // 外部类的私有属性
}
};
public void fun(){
new Inner().print() ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
new Outer().fun() ;
}
};
本程序非常的好理解，但是这道程序有那些缺点和优点呢？
1、 缺点：一直在强调一个类由属性和方法所组成，但是这个时候又多了一个内部类，所以代码的结构不好；
2、 优点：？
如果要想知道此操作的优点，可以将这个类拆分成两个不同的类。
class Outer {
private String info = "HELLO WORLD" ; // 外部类的私有属性
public void fun(){
new Inner(this).print() ;
}
public String getInfo(){
return this.info ;
}
};
class Inner { // 内部类
private Outer out ;
public Inner(Outer out){
this.out = out ;
}
public void print(){
System.out.println(this.out.getInfo()) ; // 外部类的私有属性
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
new Outer().fun() ;
}
};
这个时候就可以发现了，如果将其拆分成两个类，则在内部类访问外部类私有属性的时候将变得及其的复杂，所以内部类的唯一有点就是可以方便的访问外部类中的私有操作。
但是如果现在假设在外部想实例化内部类的对象该怎么做呢，这个时候就必须按照如下的格式完成了：
外部类.内部类 内部类的对象 = new 外部类().new 内部类() ;
之所以采用这种形式访问，主要原因还是在于内部类的生成的*.class格式：Outer$Inner.class
$是标识符的组成，但是一般而言这种操作都是在文件命名上使用的，而这种符号换到了程序之中就是“.”，所以内部类的名称就是“外部类.内部类”，之所以在实例化内部类对象的时候还必须首先实例化外部类对象，主要原因是因为内部类可以访问外部类中的私有成员，那么现在就必须保证外部类已经被实例化了才可以进行。
class Outer {
private String info = "HELLO WORLD" ; // 外部类的私有属性
class Inner { // 内部类
public void print(){
System.out.println(info) ; // 外部类的私有属性
}
};
};
public class OODemo { // 第二个类
public static void main(String args[]){
Outer.Inner in = new Outer().new Inner() ;
in.print() ;
}
};
3.9.2、使用static定义内部类
在内部类的定义中也可以使用static关键字进行内部类的定义，使用static定义的内部类就表示一个外部类，可以直接被外部类所访问，但是static定义的内部类只能访问其外部类的static属性或方法。
class Outer {
private static String info = "HELLO WORLD" ; // 外部类的私有属性
static class Inner { // 内部类
public void print(){
System.out.println(info) ; // 外部类的私有属性
}
};
};
public class OODemo { // 第二个类
public static void main(String args[]){
// Outer.Inner in = new Outer().new Inner() ;
Outer.Inner in = new Outer.Inner() ;
in.print() ;
}
};
3.9.3、在方法中定义内部类
内部类可以在任意的位置上定义，可以在if语句或while语句中，也可以在一个方法之中定义。
class Outer {
private String info = "HELLO WORLD" ; // 外部类的私有属性
public void fun(){
class Inner { // 内部类
public void print(){
System.out.println(info) ; // 外部类的私有属性
}
};
new Inner().print() ; // 实例化内部类对象，同时调用方法
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
new Outer().fun() ;
}
};
但是如果一个内部类在方法之中定义的话，此时如果要想访问方法中定义的参数或者是局部变量的话，这些参数或变量名称之前必须加上一个final的关键字声明。
class Outer {
private String info = "HELLO WORLD" ; // 外部类的私有属性
public void fun(final int x){
final int temp = 10 ;
class Inner { // 内部类
public void print(){
System.out.println(info) ; // 外部类的私有属性
System.out.println(x) ; // 外部类的私有属性
System.out.println(temp) ; // 外部类的私有属性
}
};
new Inner().print() ; // 实例化内部类对象，同时调用方法
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
new Outer().fun(199) ;
}
};
3.10、使用内部类实现链表（理解）
为了更好的方便内部类的理解，下面使用内部类完成一个链表的操作程序，为了简便，本次只完成增加及输出的操作，而且一定要使用内部类，将Node作为内部类比较合适。
巩固一个概念：内部类可以方便的访问外部类中的私有操作，实际上外部类也可以方便的访问内部类中的私有操作。
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
};
class Link {
class Node { // 节点类
private Person data ;
private Node next ; // 下一个节点
public Node(Person data){
this.data = data ;
}
public void addNode(Node newNode){
if(this.next == null){
this.next = newNode ;
} else {
this.next.addNode(newNode) ;
}
}
public void printNode(){
System.out.println(this.data.getInfo()) ;
if(this.next != null){
this.next.printNode() ;
}
}
};
private Node root ; // 一定要存在根节点
public void add(Person data){
Node newNode = new Node(data) ;
if(this.root == null){
this.root = newNode ; // 第一个节点为根节点
} else {
this.root.addNode(newNode) ;
}
}
public void print(){
if(this.root != null){
this.root.printNode() ;
}
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Link link = new Link() ;
link.add(new Person("张三",10)) ;
link.add(new Person("李四",20)) ;
link.add(new Person("王五",30)) ;
link.print() ;
}
};
如果现在要想继续完成查询操作的话，则必须存在一个对象的比较操作，而这种对象的比较操作由每个类完成。
class Person {
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public boolean compare(Person p){
if(this == p){
return true ;
}
if(p == null){
return false ;
}
if(this.name.equals(p.name) && this.age==p.age){
return true ;
} else {
return false ;
}
}
public String getInfo(){
return "姓名：" + this.name + "，年龄：" + this.age ;
}
};
class Link {
class Node { // 节点类
private Person data ;
private Node next ; // 下一个节点
public Node(Person data){
this.data = data ;
}
public void addNode(Node newNode){
if(this.next == null){
this.next = newNode ;
} else {
this.next.addNode(newNode) ;
}
}
public void printNode(){
System.out.println(this.data.getInfo()) ;
if(this.next != null){
this.next.printNode() ;
}
}
public boolean searchNode(Person data){
if(this.data.compare(data)){ // 调用对象比较操作
return true ;
} else {
if(this.next != null){
return this.next.searchNode(data) ;
}
}
return false ;
}
};
private Node root ; // 一定要存在根节点
public void add(Person data){
Node newNode = new Node(data) ;
if(this.root == null){
this.root = newNode ; // 第一个节点为根节点
} else {
this.root.addNode(newNode) ;
}
}
public void print(){
if(this.root != null){
this.root.printNode() ;
}
}
public boolean search(Person data){
if(this.root != null){
return this.root.searchNode(data) ;
}
return false ;
}
};
public class OODemo { // 第二个类
public static void main(String args[]){
Link link = new Link() ;
link.add(new Person("张三",10)) ;
link.add(new Person("李四",20)) ;
link.add(new Person("王五",30)) ;
link.print() ;
System.out.println(link.search(new Person("李四",20))) ;
}
};
4、总结
1、 一定要理解引用传递的问题，理解栈和堆的对应关系；
2、 可以通过编程语言描述出现实世界的产物；
3、 一定要理解链表的操作，可以从头到尾写出链表的基本实现：增加、查询、删除、输出；
4、 对象数组，可以保存一组对象，但是对象数组本身会受到长度的限制，那么可以通过链表来解决此问题；
5、 JDK 1.5的新特性还有很多，以后慢慢消化，但是对于这些新特性，理解即可，尽可能不要使用；
6、 static关键字可以声明属性及方法，声明的属性和方法可以由类名称直接调用；
7、 代码块只需要理解即可，一般用的较少；
8、 内部类的开发在实际的工作中使用较多，一定要明白内部类的优点和缺点，还有内部类可以在方法之中定义，但是访问方法中的参数时，必须有final，使用static定义的内部类就是外部类，可以直接通过“外部类.内部类”的形式访问。
5、预习任务
继承的基本概念及实现、继承的限制、super关键字、方法的覆写、抽象类和接口、Object类、对象多态性。
6、作业
所有代码反复熟练。
