来源: 互联网  发布时间: 2014-02-18

策划原来不是那么简单

要当一个策划需要学很多的东西，以图为证

如果是一个手机网游，这些都是不可少的。需要知道的给你三两天的时间就能摸清里面的行道也是不易的。不过很多时候需要静下心来学习。

策划所使用的工具：

 

这些都需要学习。然而这些只是策划的一小部分，还需要很多知识的辅助

 

 

    

    来源: 互联网  发布时间: 2014-02-18

三.Java的多态性
3.1 多态性的含义

通过类型转换，把一个对象当作它的基类对象对待。 
从相同的基类派生出来的多个派生类可被当作同一个类型对待，可对这些不同的类型进行同样的处理。
测试例子：

public class Game
{
	public void play()
	{
	}
}


class Football extends Game
{
	@Override
	public void play()
	{
		System.out.println("踢足球");
		super.play();
	}
}
//...Basketball
//...Tennis

调用：

Game football = new Football();
Game basketball = new Basketball();
Game tennis = new Tennis();
football.play();
basketball.play();
tennis.play();

输出：
踢足球
打篮球
打网球


可以看出football，basketball，tennis都是Game类型的，而且他们都调用play()这个方法，但是有不用的输出，这就是多态性，
由于多态性，一个父类的引用变量可以指向不同的子类对象，并且在运行时根据父类引用变量所指向对象的实际类型执行相应的子类方法。
在java中，多态性是依靠动态绑定实现的，即Java虚拟机在运行时确定要调用哪一个同名方法。
所以一个父类的引用变量可以指向不同的子类对象，并且在运行时根据所指向对象的实际类型执行相应的子类方法。
正是如此，所以上例中的对象对同样的消息(paly()方法)，做出不同的响应。


动态分为2中：
(1) 编译时多态：编译时动态重载
(2) 运行时多态：指一个对象可以具有多个类型，方法的覆盖


3.2 重写Overriding和重载Overloading

方法的重写和重载是Java多态性的不同表现。


重写Overriding
重写是父类与子类之间多态性的一种表现，子类定义的方法与父类中的方法拥有相同的名称和参数，这就是重写，也成为覆盖。
重载Overloading
重载是一个类中多态性的一种表现，即一个类中可以有同名的方法，只要他们的参数不同。


注意：
* 子类方法不能缩小父类方法的访问权限
　　* 子类方法不能抛出比父类方法更多的异常
　　* 子类可以定义和父类的静态方法同名的静态方法，Java虚拟机把静态方法和所属的类绑定，而把实例方法和所属的实例绑定。
　　* 父类的非静态方法不能被子类覆盖为静态方法
　　* 父类的私有(private)方法不能被子类覆盖
　　* 父类的非抽象方法可以被覆盖为抽象方法


3.3 向上转型和向下转型

(1)向上转型：
通过将子类对象赋值给父类对象引用变量来实现动态方法调用。也就是向上转型，向上转型是自动的。
如：
Game football = new Football();


(2)向下转型：
向下转型不是自动的，需要强制转换。
Game game = new Football();
Football football = (Football) game;//向下转型
football.play();
因为game的实际类型是Football,所以这样的向下转型是安全的。
而如果：
Game game = new Game();
Football football = (Football) game;
则会报错ClassCastException，父类是不能强制转换为子类的，因为子类有的方法父类可能没有。
简单点说，足球是一个运动项目，但是运动项目不等于就是足球。


为什么需要向下转型？

public class Game
{
}


class Football extends Game
{
	public void play()
	{
		System.out.println("踢足球");
	}
}

假如这样调用：
Game game = new Football();
game.play();
错误：The method play() is undefined for the type Game
play()在Game这个类中并没有定义，因为game是Game类型的。


3.4 Java中强制的多态

强制多态隐式的将参数按某种方法，转换成编译器认为正确的类型以避免错误。
2.0 + 2.0
将两个double的操作数相加；Java中特别声明了这种用法。
2.0 + 2
将double和int的操作数相加。Java中没有明确定义这种运算。编译器隐式的将第二个操作数转换为double型，并作double型的加法。
2.0 + "2"
将double与一个String相加。Java中同样没有定义这样的操作。所以，编译器将 double转换成String类型，并将他们做串联。





　　

    

    来源: 互联网  发布时间: 2014-02-18

一.Java面向对象理论基础
一.面向对象基础理论

1.面向对象的理解
比如一个人
对象就是现实中实实在在存在的每个个体，每个人都是一个对象，这些对象都有自己的属性，如名字，年龄，性别等。
用面向对象的思想表示，代码如下：

class Human
{
	int mName;
	int mAge;
	//...
	
	void run();
	void jump();
	//...
	
}

class就是对象的具体描述，人可以跑，跳跃等，则是class中的函数。
类是一个抽象的概念，是对具体对象的描述，而现实中的人则是类的一个个实体对象。
比如一个叫王小二的人：

Human 王小二 = new Human();

这样就创建了一个Huamn的对象王小二，王小二是一个Human，则他拥有Human的一切属性和方法。

在面向对象中，我们不用关心类的具体实现，只需要知道其接口，就像开车一样，我们不会关心汽车的构造，发动机的具体实现，只需要知道方向盘，油门，刹车等等的使用

王小二.run();

2.类之间的关系
依赖关系：use-a A类中的一个方法操作了另一个类中的对象。
聚合关系：has-a A类中的对象包含B类的对象。
继承关系：is-a  A继承了B类，此时A类不仅有了B类的方法，还加入了自己的方法。


3.面向对象的特性
（1）封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，
即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
（2）继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），
而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
java只支持单继承。
（3）多态性：
多态性是指允许不同类的对象对同一消息作出响应。
函数可以同名（参数不同，参数个数或者参数类型不同）
boolean isEquals2(int i);
boolean isEquals2(double i);
在调用的时候，不用区分这两个函数，系统会根据函数的参数类型，自动区分调用。


4.对象的接口
如上面Human的对象王小二，他提供的接口就是Human类中的public函数，

class Human
{
	String mNmae;
	int mAge;
	
	public void setAge(int age)
	{
		mAge=age;
	}
}

这样在外部就可以调用这个函数，王小二.setAge();我们只需要知道通过setAge()就可以设定年龄，而不需要关系具体的实现，这就是封装的特性。
只需要提供一个接口，供外部来调用。作为外部的调用者唯一关心的： 接口是什么。
在类中实现的时候，用public,private,protected来控制外部的访问权限。


5.关于继承
比如有一个Dog类，表示狗这个物种，有一个Bird类，表示鸟，他们都是动物，有共同的属性，则可以让他们继承Animal类

class Animal
{
	String mName;
	int mSex;

	void run();
	void jump();
}

然后Dog类可以继承自Animal

class Dog extends Animal
{
	
}

这样Dog就自动拥有了Animal的属性。

java中的每一个类都必须继承自另一个类，如果没有使用extends则隐式的继承Object类，Object类是所有类的超类，
JDK中有说明：

--类 Object
-java.lang.Object
public class Object
类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
从以下版本开始：
JDK1.0