JAVA学习笔记

这个学期报了一门android的课程，可是自己连java都没有学习过，所以自己借了本java的书本看了起来。也看了大概一个礼拜了，感觉java里面的一些关于对象，继承的东西比较抽象，不知道是不是我借的这本书太难了，很多专业术语记住就忘记了。所以还是自己在这里做个笔记，免得忘记。

首先java与c的大致语法是一样的，只不过有一些区别：

1.java里面是没有指针的概念的

2.java里面的方法对应c里面的函数

3.java里面的状态对应c里面的变量

4.自己以前写c是从main函数开始的，而java的话是从类开始的

5.java多了以下概念：

这里重点记录的是一些关于面向对象的知识点

1.对象

软件对象是现实世界对象的模式化产物，他们也有状态
和行为。软件对象把状态用数据表示并存放在变量里，而行为则用方法实现。实际上，软件
对象还包括了数据结构和使用这些数据结构的代码。因此也可以说：软件对象是现实世界客
观事务的软件化模拟，是变量（数据和数据结构）和相关方法（对数据操作和对象管理的程
序）的软件组合。

创建对象包括声明、实例化和初始化三方面的内容。通常的格式为  :
1.  声明对象
对象声明实际上是给对象命名，也称定义一个实例变量。对象声明的一般格式为：
type name
其中，type是一个类的类名，用它声明的对象将属于改类；name 是对象名。
例如：
Date today；
Rectangle myRectangle;
第一条语句说明了对象today属于Date类，第二条语句说明了对象 myRectangle
属于 Rectangle 类。对象说明并没有体现一个具体的对象，只有通过实例化后的对
象才能被使用。
2.  实例化对象
实例化对象就是创建一个对象。实例化对象意味着给对象分配必要的存储空间，用
来保存对象的数据和代码。实例化后的每个对象均占有自己的一块内存区域，实例
化时，每个对象分配有一个“引用” （reference）保存到一个实例变量中。“引用”
实际上是一个指针，此指针指向对象所占有的内存区域。
因此，对象名（变量）实际上存放的是一个被实例化之后的对象所占有的内存区域
的指针。
例如：
type objectName = new type ( [paramlist] );
运算符 new 为对象分配内存空间 ,实例化一个对象  。new 调用对象的构造方法,返
回对该对象的一个引用(即该对象所在的内存地址)。用 new 可以为一个类实例化，
多个不同的对象。这些对象分别占用不同的内存空间，因此改变其中一个对象的状
态不会影响其它对象的状态  。
3．初始化对象
生成对象的最后一步是执行构造方法,进行初始化。由于对构造方法可以进行重写
，所以通过给出不同个数或类型的参数会分别调用不同的构造方法。
例子：以类 Rectangle 为例,我们生成类 Rectangle的对象:
Rectangle  p1=new Rectangle ();
Rectangle  p2=new Rectangle (30，40);
关于对象的引用

这个概念自己一开始没有想明白，查找了相关的资料：

1. 引用类型（reference type）：引用类型是用在对象上的。一个对象可以被多个引用所指向，但同一时刻，每个引用只能指向唯一的一个对象。如果一个对象被多个引用所指向，那么无论哪个引用对对象的属性进行了修改，都会反映到其他的引用当中。

2.在java里，永远无法直接操作对象，对对象的所有操作都是通过对象的引用来间接完成的。

public class People{int age = 20;public void change(People people){people = new People();people.age = 30;}public static void main(String[] args){People people = new People();int age = people.age;System.out.println(age); //输出 20people.change(people);int age2 = people.age;System.out.println(age2); //还是输出20}}

People people=new People(); //这句话在内存的堆中生成了一个 People类型的对象，并且在内存的栈中生成了一个 People类型的引用，这个引用指向了堆中生成的People类型的对象
people.change(people); //传到方法的时候创建了一个新的引用，也指向刚才在堆中生成的People类型的对象
public void change(People people)
{
people = new People(); //在内存的堆中又生成了一个 People类型的对象，并将方法中的那个引用从指向旧的People对象改成指向这个新的对象

people.age = 30; //这里通过新的引用修改的是方法中新产生的对象的age属性，而不是外面那个对象的age属性
}

3. 如果一个类包含了属性与方法，那么该类的每一个对象都具有自己的属性，但无论一个类有多少个对象，这些对象共享同一个方法（引用同一个方法）。

4. 关于方法参数传递的总结：对于Java中的方法参数传递，无论传递的是原生数据类型还是引用类型，统一是传值（pass by value），而不是传递内存地址。C#里面有ref可以传递内存地址

5. 什么类型的引用就能指向什么类型的对象，不能指向其他类型的对象，比如People类型的引用就能指向People类型的对象，但不能指向Student类型的对象。比如：
People people = new People(); // 正确
People people = new Student(); //错误

6. 构造方法（Constructor）：构造方法用于完成对象属性的初始化工作，构造方法的特点：
a) 构造方法的名字必须与类名完全一致（包含大小写）
b) 构造方法没有返回值，连void也不能出现。
c) 如果在定义一个类的时候，没有为类声明构造方法，那么Java编译器会自动为类添加一个没有参数且方法体为空的构造方法（默认的构造方法）
d) 如果在定义一个类的时候，为类声明了构造方法，那么Java编译器就不会再为类添加构造方法了。
e) 不能显式调用类的构造方法，构造方法通常是通过new关键字隐式调用。

7. 默认的构造方法：构造方法没有参数且方法体为空。

8. new关键字在生成对象时完成了三件事情：
a) 为对象开辟内存空间。
b) 调用类的构造方法进行对象的一系列的初始化。
c) 将生成的对象的地址返回。

9. 使用new来生成对象的时候，后面的小括号()表示构造方法的参数列表，如果构造方法不接收参数，那么小括号中的内容为空；如果构造方法接收参数，那么小括号中的实际参数就需要与构造方法定义中的形式参数保持一致（参数数量一致、参数类型一致、按照顺序逐一赋值）。

2.封装

“封装”是 OOP 语言的优点之一。把一个对象的数据加以包装并置于其方法的保护之下
称为封装。所谓封装就是对数据的隐藏。封装实现了把数据和操作这些数据的代码包装成为
一个对象（即离散的部件），而数据和操作细节（方法）隐藏起来。如果增加某些限制，使
得对数据的访问可按照统一的方式进行，那些能比较容易地产生更为强壮的代码。
OOP 语言提出一种（或称为协议），以保证对数据进行统一的操作。通常的做法是：程
序和对象数据的交互作用通过一个公开的接口进行，而不直接进行操作。由于把数据封装在
对象中，所以，访问对象中的数据只有一种途径，那就是利用一个公开的接口。
实际上，封装在程序和数据之间设置了一道栅栏，它可以阻止一部分的设计错误，不至
于涉足应用程序其他部分的数据。

3.消息

一个单独的对象一般不十分有用，而作为一员出现在包含有许多其他对象的大程序或应
程序之中，通过这些对象的相互作用，程序员可实现高层次的操作和更负责的功能。某此
象通过向其他对象发送消息与其他对象进行交互作用和通信。
消息是以参数的形式传递给某方法的。一个消息通常由三部分组成：
1.  消息传送到对象的名称。
2.  要执行的方法的名称。

3.  方法需要的任意参数。 

4.类

类是一个蓝图或样板，定义了某种类型的所有对象的变量和方法。
在 java 语言中，Java  程序的基本单位是类，也就是说：一个 Java 程序是由多个类组成
的。定义一个类与定义一个数据类型是有区别的。在程序设计语言中，把定义数据类型的能
力作为一种很重要的能力来对待。在面向对象的语言中，类的功能更强大，这是因为类不仅
含有定义数据类型的功能，而且还包含了对方法的定义。
对象实际是类中的一个实例。生成实例的过程叫做把“一个对象实例化”。一个实例化
的对象实际上是由若干个实例变量和实例方法组成的。当你创建出一个类的实例时，系统将
为实例变量指定内存，然后你就可以利用实例方法去做某些事情。

类是组成 Java 程序的基本要素。它封装了一类对象的状态和方法，是这一类对象的
原型。定义一个类，实际上就是指定该类所包含的数据和对数据进行操作的代码。
   类通过关键字 class 来定义，一般格式为：

【类说明修饰符】class类名【extends  子句】【implements子句】

type instance-varable;
the methodname(parameter-list){method-body;} 

（1）  class 是类说明关键字。
（2） 类名是由程序员自己定义的 Java 标识符，每个类说明必须有 class 和类名。  
（3） 类说明修饰符包括：
  abstract  说明一个类为抽象类，抽象类是指不能直接实例化对象的类。
  final  说明一个类为最终类，即改类不能再有子类。
  public  说明类为公共类，该类可以被当前包以外的类和对象使用。
  private  说明类为私有类。
（4）  extends 子句用于说明类的直接超类。
（5）  implements子句用于说明类中将实现哪些接口，接口是 Java 的一种引用类
型。
（6） 类体包含了变量和方法。在类体中定义的数据、变量和方法称为类的成员，
或称为实例变量和实例方法。

5.继承

继承是指建立子类的能力。子类继承了父亲的特征和功能。类的层次结构类似于一棵数
结构，也像一个家庭谱系。它显示了根和它的导出类之间的关系。
子类从它先辈类那里继承了代码和数据，这样，它就可以执行先辈类的功能和访问先辈
的数据。一个纯面向对象程序设计的语言将具有严格的继承性。
通过对象、类，我们实现了封装，通过子类我们可以实现继承。例如，公共汽车、出租
、货车等都是汽车，但它们是不同的汽车，除了具有汽车的共性外，它们还具有自己的特
如不同的操作方法，不同的用途等)。这时我们可以把它们作为汽车的子类来实现，它们
承父类(汽车)的所有状态和行为，同时增加自己的状态和行为。通过父类和子类，我们实
了类的的层次，可以从最一般的类开始，逐步特殊化，定义一系列的子类。同时，通过继
也实现了代码的复用，使程序的复杂性线性地增长，而不是呈几何级数增长。 

6.抽象

面向对象的程序设计系统鼓励充分利用“抽象”。在现实世界中，人们正是通过抽象来
理解复杂的事务。例如：人们并没有把汽车当作成百上千的零件组成来认识，而是把它当作
具有自己特定行为的对象。人们可以忽略发动机、液压传输、刹车系统等如何工作的细节，
而习惯于把汽车当作一个整体来认识。
包含通用对象类的库叫作类库。

7.多态性

面向对象程序的最后一个概念是多态性。凭借多态性，你可以创建一个新的对象，它具
有与基对象相同的功能，但是这些功能中的一个或多个是通过不同的方式完成的。例如：在
Java 中你可以凭借多态性，通过一个画圆的对象，来创建一个画椭圆或矩形的对象。不管是
画圆，画椭圆还是画矩形的方法，它们都有一个相同的方法名，但以不同的方式完成他们的
画圆的功能

8.包

包是一种命名和可视控制的机制，用户可以把某些类定义在一个包
中，也可以对定义在这个包中的类施加访问权限，以限定包外或包
内的程序对其中的某些类进行访问。
定义包的格式：
 package pkg；
Java 的文件系统将存储和管理这个包。例如：属于 pkg 包中的.class
文件将存储到目录 pkg。注意：目录与包的名字完全一样。
package 语句可以创建包的层次结构，通过使用逗号，把每个包分开。
多级包层次结构的一般格式为：
 package pkg1[.pkg2[.pkg3]]
包层次结构必须反映 Java 开发系统的文件系统。比如：pacakge
java.awt.Image;

9.接口

接口与类存在着本质的差别，类有它的成员变量和方法，而接口只有
常量和方法协议，从概念来讲，接口是一组方法协议和常量的集合。
接口在方法协议与方法体实体之间只起到一种称之为界面的作用，这
种界面限定了方法实体中的参数类型一定要与方法协议中所规定的
参数类型保持一致，除此以外，这种界面还限定了方法名、参数个数
及方法返回类型的一致性。因此，在使用接口时，类与接口之间并不
存在子类与父类的那种继承关系，在实现接口所规定的某些操作时只
存在类中的方法与接口之间保持一致的关系，而且一个类可以和多个
接口之间保持这种关系，即一个类可以实现多个接口。 

当初看接口这个概念并不是很理解，所以又看了一遍，下面是自己对接口的理解：

1.由于java中的类不支持多重继承，也就是说一个类只能有一个直接父类。但是接口就不一样了，接口可以连接多个类

，这样就弥补了java不支持多重继承的缺点。

2.接口中的各个类是没有关联的，这样用起来肯定比较简便嘛。

1.14.2.2  接口的定义
格式：
access interface name
{
 return method-name(parameter-list);
 type final-varname=value;
 
}
其中，access是访问修饰符。它只有 public 和未指定访问修饰符
两种情况。当未指定访问修饰符时，该接口只能为同一个包中的
其他成员所用；当 public修饰符说明时，该接口可以被其他任何
代码使用。name 是接口的名字，可以是任何有效的标识符。接
口体包括方法协议和常量，它们都用分号结束。在接口中定义的
常量必须用变量名标识。他们隐式为 final 和 static，不能被实现
类所改变。
例：interface Back
{
 void c_back(int param);
 int SOON=4;
}
该接口定义了一个方法协议，其参数为整数类型；还定义了一整
数常量，其变量名为 SOON。该接口只能为同一个包中其他成员
所用。

　　java的接口到底起什么作用？

 

　　1、从书中看到的是java程序的接口中只定义了常量及空方法，空的方法有什么用呢？还要在类中写方法体，那还要接口干什么？

 

　　2、一个程序中写了2个接口，并在同一个类中写方法体，这与多继承有什么关系。

 

　　3、包中那些已定义的接口，怎么知道那里面定义了什么方法。

 

　　说到底，接口有什么实际意义，哪本书都不讲，一味的讲是多继承，不结合实际实在不好懂。

 

 

　　Madai的理解是：

　　java接口的用处主要体现在下面几个方面：

 

　　（1）通过接口可以实现不相关类的相同行为，而不需要了解对象所对应的类。

 

　　（2）通过接口可以指明多个类需要实现的方法。

 

　　（3）通过接口可以了解对象的交互界面，而不需了解对象所对应的类。

 

 

　　Clkrst给出了更详细的解释：

　　类描述了一个实体，包括实体的状态，也包括实体可能发出的动作。

 

　　接口定义了一个实体可能发出的动作。但是只是定义了这些动作的原型，没有实现，也没有任何状态信息。

 

　　所以接口有点象一个规范、一个协议，是一个抽象的概念；而类则是实现了这个协议，满足了这个规范的具体实体，是一个具体的概念。

 

　　从程序角度，简单理解，接口就是函数声明，类就是函数实现。需要注意的是同一个声明可能有很多种实现。

 

　　所以就你的问题：

　　1、接口中定义类方法的原型，但是不能说是空方法，因为空方法的意思是有实现体，只不过实现体是空操作。实际上接口没有定义任何实现体。具体的实现体都是在实现接口的类中，接口只是定义了这些方法的调用方式。

 

　　你当然也可以不用接口，直接在类里面写方法，但是如果你的一组方法需要在很多类里实现，那么把它们抽象出来，做成一个接口规范，不是更好么？

 

　　2、一个类描述了一个实体，这个实体可能是一个复杂的对象，它的动作很多，如果把这些动作分类，用接口a定义其中的某一组动作，接口b定义其中的另外一组动作，这样的结构，比较清楚。

 

　　这种方式具备了多继承的优点，避免了多继承的缺陷。实际上在历史上，接口在很大程度上，是为了解决多继承带来的种种问题而设计出来的。

 

　　3、包中那些已定义的接口，怎么知道那里面定义了什么方法。

 

　　接口里定义了方法的输入输出，这些都是协议，具体的实现都在每个类中。对于很多只需要抽象接口的地方，不需要知道具体的类是什么，只要这个类实现了这个接口就可以了。

由于以前没java基础，看这部分抽象东西的时候真的是很头疼，所以做做笔记还是很必要的。