JAVA的基础语法等都跟C有很大的相似之处，所以这里就不多啰嗦了。直接从数组开始。
数组：
1.声明
int [] a;
在声明的过程中，并没有分配空间给数组。我们可以在声明的同时，用new来分配相应的空间
int [] a = new int[100];
这里开辟了一个空间为100大小的数组，内存分配也完成了。
我们可以在声明的同时也确定元素个数
int [] a = new int[]{1,3,5,7,9};
面向对象(重点)
class Human
{
int height;
void breath()
{
System.out.println("呼呼呼..");
}
}
Human类包含两个成员:一个数据成员height,另一个是方法breath()。
▲数据成员即为属性,方法即为行为。
通过对象来调用方法或者数据成员
Human person = new Human();
person.breath();
通过方法来使用对象的私有变量
class Human
{
private int height;
int getHeight()
{
return height;
}
}
主函数省略没写，如输出结果默认height为0
Human person = new Human();
person.height();
构造方法
特征:1.与类名相同
2.无返回值
class Human
{
int height;
Human(int h)
{
height=h;
}
}
使用构造器
Human person = new Human(160); //传参
构造方法重载
class Human
{
int height;
Human(int h)
{
height=h;
}
Human(int h,String name)
{
height=h;
System.out.println("我叫"+name);
}
}
JAVA会根据你传入的参数选择构造器进行构造。
当没写构造器的时候，系统默认给你使用空构造器。
封装与接口
Java通过三个关键字来控制对象的成员的外部可见性(visibility): public, private, protected。
- public: 该成员外部可见，即该成员为接口的一部分
- private: 该成员外部不可见，只能用于内部使用，无法从外部访问。
(protected涉及继承的概念，放在以后说)
方法一般置为public作为接口,而重要的数据成员一般置为private。
class Human
{
private int height;
public int getHeight()
{
return height;
}
}
也就是说在外部直接使用height是错误的。必须通过调用getHeight()方法得到其值
Human person = new Human();
System.out.println(person.getHeight());
接口(interface)
以杯子为例，定义一个杯子的接口
interface Cup{
void addWater(int h);
void drinkWater(int h);
}
在interface中，我们
- 不需要定义方法的主体
- 不需要说明方法的可见性(接口默认为public)
我们可以在一个类的定义中实施接口，比如下面的MusicCup (可以播放音乐的杯子):
class MusicCup implements Cup
{
public void addWater(int h)
{
water = water + h;
}
public void drinkWater(int h)
{
water = water - h;
}
private int water = 0;
}
我们使用接口时，必须将接口中的所有方法都要写出，否则将会报错。
当然除了使用接口，我们在类中也可以定义其他方法。例如：
class MusicCup implements Cup
{
public void addWater(int h)
{
water = water + h;
}
public void drinkWater(int h)
{
water = water - h;
}
public int getWater()
{
return water;
}
private int water = 0;
}
实施多个接口
一个类可以实施不止一个的interface。比如我们有下面一个interface:
interface MusicPlayer{
void play();
}
将MusicCup实施两个接口
class MusicCup implements Cup,MusicPlayer
{
public void addWater(int h)
{
water = water + h;
}
public void drinkWater(int h)
{
water = water - h;
}
public void play()
{
System.out.println("lala....la");
}
private int water = 0;
}
类的继承
Human类(基类)
class Human
{
public int getHeight()
{
return height;
}
public void growHeight(int h)
{
height = height + h;
}
public void breath()
{
System.out.println("hu....hu.....hu");
}
private int height;
}
现在我们定义一个女人(Woman)类,使用继承，使用基类的基本特征,避免重复
class Woman extends Human //此时子类具有父类的所有方法(breath().growHeight().getHeight等等)
{
public Human giveBirth()
{
System.out.println("生宝宝啦");
return (new Human(20));
}
}
加入main方法测试
class Test
{
public static void main(String [] args)
{
Woman aWoman = new Woman();
aWoman.growHeight(120); //直接调用父类的方法
System.out.println(aWoman.getHeight());
}
}
方法覆盖
class Woman extends Human
{
public Human giveBirth()
{
System.out.println("生宝宝啦");
return (new Human(20));
}
public void breath()
{
super.breath(); //调用父类的breath()方法
System.out.println("su....");
}
}
注意，此时我们位于衍生层，依然可以通过super来调用基类对象的breath()方法。当我们外部调用Woman类时，由于方法覆盖，就无法再调用基类对象的该方法了。
构造方法继承之后
在了解了基类对象和衍生层的概念之后，衍生类的构造方法也比较容易理解。
我们要在衍生类的定义中定义与类同名的构造方法。在该构造方法中:
- 由于在创建衍生对象的时候，基类对象先被创建和初始化，所以，基类的构造方法应该先被调用。我们可以使用super(argument list)的语句，来调用基类的构造方法。
- 基类对象创建之后，开始构建衍生层 (初始化衍生层成员)。这和一般的构建方法相同，参考构造方法与方法重载
class Human
{
public Human(int h)
{
height = h;
}
private int height;
}
class Woman extends Human
{
public Woman(int h)
{
super(h);
System.out.println("我们让父类中的height初始化");
}
}
关于static
类的所有对象共享“人口”数据。这样的数据被称为类数据成员(class field)。
在类定义中，我们利用static关键字，来声明类数据成员，比如:
class Human
{
private static int population;
private static boolean is_mammal = true;
}
我们定义了两个类数据成员: population和is_mammal。所有Human对象都共享一个population数据；任意Human对象的is_mammal(是哺乳动物)的属性都为true。
类数据成员同样要设置访问权限。对于声明为public的类数据成员，可以利用class.field的方式或者object.field(如果存在该类的对象)的方式从外部直接访问。这两种访问方式都是合理的，因为类数据成员可以被认为是类的属性，可以认为是所有成员共享的属性。如果类数据成员被定义为private，那么该类数据成员只能从类的内部访问。
(上面将is_mammal设置成了public，只是为了演示。这样做是挺危险的，万一有人使用 Human.is_mammal=false;，所有人类都遭殃。还是那个基本原则，要尽量将数据设置为private。)
static方法
我们也可以有类方法，也就是声明为static的方法。类方法代表了类可以实现的动作，其中的操作不涉及某个具体对象。如果一个方法声明为static，那么它只能调用static的数据和方法，而不能调用非static的数据和方法。
下面我们增加一个static方法getPopulation()，该方法返回static数据population:
class Human
{
private static int population;
private static boolean is_mammal = true;
public static int getPopulation()
{
return population; //类方法只能访问类数据成员
}
}
两种方法调用类方法。类名.方法 或者 对象.方法
class Test
{
public static void main(String [] args)
{
System.out.println(Human.getPopulation()); //直接是 类名.方法
Human person = new Human();
System.out.println(person.getPopulation()); //对象.方法
}
}
final定义
final关键字的基本含义是: 这个数据/方法/类不能被改变了。
- final基本类型的数据: 定值 (constant value)，只能赋值一次，不能再被修改。
- final方法: 该方法不能被覆盖。private的方法默认为final的方法。
- final类: 该类不能被继承。
普通类型的对象也可以有final关键字，它表示对象引用(reference)不能再被修改。即该引用只能指向一个对象。但是，对象的内容可以改变 (类似于C中的static指针)。我们将在以后介绍对象引用。
如果一个基本类型的数据既为final，也是static，那么它是只存储了一份的定值。这非常适合于存储一些常量，比如圆周率。
interface继承
在实施接口中，我们利用interface语法，将interface从类定义中独立出来，构成一个主体。interface为类提供了接口规范。
在继承中，我们为了提高程序的可复用性，引入的继承机制。当时的继承是基于类的。interface接口同样可以继承，以拓展原interface。
接口继承(inheritance)与类继承很类似，就是以被继承的interface为基础，增添新增的接口方法原型。比如，我们以Cup作为原interface:
interface Cup{
void addWater(int w);
void drinkWater(int w);
}
我们在继承Cup的基础上，定义一个新的有刻度的杯子的接口，MetricCup
interface MetricCup extends Cup
{
void getWater(); //返回水量
}
interfacede的多重继承
在Java类的继承中，一个衍生类只能有一个基类。也就是说，一个类不能同时继承多于一个的类。在Java中，interface可以同时继承多于一个interface，这叫做多重继承(multiple inheritance)。
比如我们下面有一个player接口
interface Player{
void play();
}
我们新增一个MusicCup的接口。它既有Cup接口，又有Player接口，并增加一个display()方法原型。
interface MusicCup extends Player,Cup
{
void display();
}
抽象类
在生活中，我们会有一些很抽象的概念。这些抽象的概念往往是许多类的集合，比如:
- 粮食 (可以是玉米、小麦、大米)
- 图形 (可以是三角形、圆形、正方形)
再比如，我们之前举出了例子:
- 人类 (可以是男人、女人)
抽象到具象必须完善抽象类中的方法，否则该类还是抽象类
abstract class Food
{
public abstract void eat();
public void happyFood()
{
System.out.println("好好吃");
}
}
类中的方法可以声明为abstract，比如上面的eat()。这时，我们不需要具体定义方法，只需要提供该方法的原型。这与接口类似。当我们在比如Corn类中继承该类时，需要提供eat()方法的具体定义。
类中的另一个方法happyFood()并不是
当一个类中出现abstract方法时，这个类的声明必须加上abstract关键字，否则Java将报错。一个abstract类不能用于创建对象。
所有内容来自于
作者：Vamei 出处：http://www.cnblogs.com/vamei
笔记整理:Ten10