java 基础

一 4类8种基本数据类型

逻辑型   - boolean

文本型   - char

整数型   - byte short int long

浮点数型 - float double

☆java各整数类型有固定的表数范围和字段长度，其不受具体操作系统的影响以保证java程序的可移植性。

☆java 语言的整型常量默认为int型，声明long型常量后可以加‘l’或‘L’.

☆java浮点类型常量默认为double型，如要声明一个常量用float型，则要在数字后面加f或F.

基本数据类型转换

☆ boolean 类型不可以转换为其他的数据类型。

☆ 容量小的类型自动韩国的为容量大的数据类型;大小排序为：

byte short char ->int -> long ->float ->double.

Byte short char之间不能互相转换。

☆有多种数据混合运算时，会自动转换成最大的数据类型再进行计算。

容量大的数据类型韩国的为容量小的数据类型时，要加上强制转换符。

字符串连接

☆“+”运算符两侧的操作数中只要有一个是字符串（String）类型，系统会自动将另一个操作数转换为字符串后再进行连接。

☆ 当进行打印时，无论任何娄类型，都自动转为字符串进行打印。

★局部变量要初始化才能使用。成员变量不初始化也能使用。因为成员变量系统会自己赋默认的值。

★new出来的东西都在堆里。

约定俗成的命名规则

◇类名的首字母大写

◇变量名和方法名的首字母小写

◇运用驼峰标识

二、标识符命名规则

a 标识符只能由字母、数字、下划线 “_” 和 美元符号“$ ”或者人民币符号“￥”组成

b数字不能开头，即标识符的第一个字母必须是字母或下划线，不能是数字。

c不能把关键字和保留字作为标识符。

d标识符的要有一定的意义。

e标识符严格区分大小写。

f标识符没有长度限制，但应当符合“min-length && max-information”原则。

方法（C++中叫函数）

☆Java语言中使用下述形式调用方法： 对象名.方法名（实参列表）。

☆实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配。

☆传递参数时，遵循值传递的原则：基本类型传递的是该数据值本身。引用类型传递的是对对象的引用。而不是对象本身。

构造方法（构造函数）

◇使用new+构造方法创建一个新的对象

◇构造函数是定义在java娄中的一个用来初始化对象的函数。

◇构造函数与类同名且没有返回值。

◇不能在前面加void

◇没有指定构造函数时，编译器会自动添加。指定后就不会自动添加，会报错。

四 程序执行过程：

三、final

　根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。

final类不能被继承，没有子类，final类中的方法默认是final的。

final方法不能被子类的方法覆盖，但可以被继承。

final成员变量表示常量，只能被赋值一次，赋值后值不再改变。

final不能用于修饰构造方法。

注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

1、final类

final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

2、final方法

如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法

使用final方法的原因有二：

a 把方法锁定，防止任何继承类修改它的意义和实现。

b高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。

3、final变量（常量）

用final修饰的成员变量表示常量，值一旦给定就无法改变！

final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。

一旦给final变量初值后，值就不能再改变了。

另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数

中。这两个地方只能选其一。

4、final参数 
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

方法的重载

◇方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。调用时，用根据不同的参数表选择对应的方法。

◇构造方法也可以重载。

★重载方法满足以下条件

☆方法名相同。

☆方法的参数类型，个数，顺序至少有一项不相同。

☆方法的返回类型可以不相同。

☆方法的修饰符可以不相同。

★在一个类中不允许定义另个方法名相同，并且参数签名也完全相同的方法。假如存在这样的两个方法，Java 虚拟机在运行时就无法决定到底执行哪个方法。参数签名是指参数的类型，个数和顺序。

覆盖方法

如果在子类中定义的一个方法，其名称，返回类型及参数签名正好与父类中某个方法的名称，返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。

★覆盖方法必须满足多种约束

1）子类方法的名称，参数签名和返回类型必须与父类方法的名称，参数签名和返回类型一致

2) 子类方法不能缩小父类方法的访问权限。

3）子类方法不能抛出比父类方法更多的异常。

4）方法覆盖只存在于子类和父类（包括直接父类和间接父类）之间，在同一个类中方法只能被重载，不能被覆盖。

this关键字

在类的访求定义中使用的this关键字代表使用该方法的对象引用。

当必须指定当前使用方法的对象是谁时要使用this。

this可以看作是一个变量，它的值是当前对象的引用。

◇1、我们想通过构造方法将外部传入的参数赋值给类的成员变量，构造方法的形式参数名称与类的成员变量名相同。如：

class Person

{

String name;

public Person(String name)

{

this.name = name;

}

}

◇2、假设有一个容器类和一个部件类，在容器类的某个方法中要创建部件类的实例对象，而部件类的构造方法要接受一个代表其所在容器的参数。如

class Container

{

Component comp;

public void addComponent()

{

comp = new Component(this);

}

}

class Component

{

Container myContainer;

public Component(Container c)

{

myContainer = c;

}

}

◇3、构造方法是在产生对象时被java系统自动调用的，我们不能再程序中像调用其他方法一样去调用构造方法。但我们可以在一个构造方法里调用其他重载的构造方法，不是用构造方法名，而是用this（参数列表）的形式，根据其中的参数列表，选择相应的构造方法。

public class Person

{

String name;

int age;

public Person(String name)

{

this.name = name;

}

public Person(String name,int age)

{

this(name);

this.age = age;

}

}

◇3、在一个构造函数中调用另一个构造函数时，用this关键字

public class Flower{

private int petalCount=0;

private String s=new String("null");

public Flower(int petals){

petalCount=petals;

}

public Flower(String ss){

s=ss;

}

public Flower(String s,int petals){

this(petals); //java中在一个构造函数中可以调用一次其他的构造函数，并且这条语句 必须在这个构造函数的第一行

this.s=s;

}

}

public class love{

String Maybe="love";

public love(String Maybe){

System.out.println("Maybe=" + Maybe);

System.out.println("this.Maybe="+this.Maybe);

this.Maybe=Maybe;

System.out.println("this.Maybe="+this.Maybe);

}

public static void main(String[] args){

love s=new love("love you");

}

}

static 关键字

★类体定义的变量为成员变量，分实例变量和类变量（也叫静态变量）。用static定义的变量是类变量。两者的区别是：

不同的实例变量被分到不同的内存空间。类变量只有一个内存空间，即所有的对象都共用这个类变量。

类变量可能通过对象访问，也能通过类名直接访问。

★静态方法和实例方法的区别主要体现在两个方面：

在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。

静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。

静态方法不能直接访问非静太变量。

非静态方法可以直接访问静态变量。

package和import语句

包：是为了解决类的命名冲突引入的机制。

约定俗成的给包命名的方法：把公司的域名倒过来

Package语句作为java源文件的第一条语句。指明该文件中定义 的类所在的包。

Java编译器把包对应于文件系统的目录管理，package语句中，用‘.’来指明包（目录）的层次，例如package com.sun;则该文件中所有的类位于.\com\sun目录下

总结：

1.如果你要把一个类放在包下面，第一句写package,你编译出来的类必须位于正确的目录下面。

该类的源码可能会产生影响（解决办法：删除或转移到别的目录）

2.如果想在另一个类里面引用包里面的类，要把名字写全。（相当用文件的绝对路径访问）或者用import导入，但位于同一个包中的类不需要引入

3.必须class文件的最上层包中的父目录位于classpath下面。（注意点之一）

4.编译后，执行一个类的时候也需要把包名写全，不然无法执行。（注意点之二）

编译出来的类必须位于正确的目录下

I该类的源码可能会产生影响

II删除或转移到另外的目录

d.另外的类想访问的话：

I写全名

II引入  1）*     2）具体类名

III访问位于同一个包中的类不需要引入

e.必须class 文件的最上层包的父目录位于classipath下

补：执行一个类，需要写全包名

J2SDK中主要的包介绍（在jdk5.0/jre/lib/rt.jar里面，可用解压软件解开查看）

Java.lang－包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能

Java.awt－包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）。

Java.applet－包含applet运行所需的一些类

Java.net－包含执行与网络相关的操作的类

Java.io－包含能提供多种输入/输出功能的类

Java.util－包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数

其中就Java.lang包不用引入就能直接使用，其他包里面的类都要用import引入才能使用。

jar文件

命令： jar –cvf xx.jar *.*

访问控制

★Java权限修饰符public protected private 置于类的成员定义前，用来限定其他对象对象对该类对象成员的访问权限。

修饰符	类内部	同一个包	不同包子类	任何地方
private	Yes
default	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

★对于classr 权限修饰只可以用public 和default

public 类可以在任意地方被访问。

default 类只可以被同一个包内部的类访问。

类的继承

◇继承旧属性

◇添加新的属性

◇不支持多重继承

★使用extends关键字实现类的继承机制。

class 子类名 extends 父类名

{

……

}

★通过继承，子类自动拥有了基类的所有成员（变量和方法）

★Java只支持单继承，不允许多继承。一个子类只能有一个基类，一个基类可以派生多个子类。

★子类的继承性：不继承构造方法。子类继承父类的成员就好像子类自己声明定义的一样。

★子类和父类在同一包中的继承性：不能继承privat基类的变量和方法。其他的都可以。

★子类和父类不在同一包中的继承性：继承protected、public基类的变量和方法

方法的重写

在子类中可以根据需要对从基类中继承来的方法进行重写。

重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。

重写方法不能使用比被重写方法更严格的访问权限。

可以操作自身定义和继承下来的变量。

用super使用已被隐藏的父类方法。

成员变量的隐藏

子类可以从父类继承成员变量， 只要子类的成员父类中的成员变量同名时，就可以隐藏父类的成员变量。

关键字 super

super是一个引用。指向父类。可以和this比较。this指向本身的。

在 java类中 使用super来引用基类的成公。

继承中的构造方法

子类的构造的过程中必须调用其基类的构造方法。

子类可以在自己的构造方法中作用super（argumnet_list）调用基类的构造方法。

使用this(argumnet_list)调用本类的另外的构造方法。

如果调用super， 必须写在子类构造方法的第一行。

如果子类的构造方法中没有显示地调用基类构造方法。则系统默认调用基类无参数的构造方法。

如果子类构造方法中好即没有显式调用基类构造方法，而基类中又没有无参的构造方法，则编译出错。

Object类

Object是所有java类的根基类

如果在类的声明中未用extends关键字指明其基类，则默认基类为Object类

Public class Persom {

……

}

等价于：

Public class persom extends Object {

……

}

Object类中的hashCode和equals函数有着非常紧密的逻辑关系。当然这个逻辑关系是人赋予它的。在没有覆盖这两函数函数之前，hashCode返回的是地址，equals比较的也是两个应用对象的地址。 也就是说如果两个对象equals，那么hashcode值也应该一样。

对象内容的比较才是设计equals()的真正目的，Java语言对equals()的要求如下，这些要求是必须遵循的。否则，你就不该浪费时间：

对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。

反射性：x.equals(x)必须返回是“true”。

类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。

还有一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。

任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。

hashCode()的返回值和equals()的关系如下：

如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。

如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等。

在Object类中定义的几个hashCode约定如下：

1. 在同一应用中，一个对象的hashCode函数在equals函数没有更改的情况下，无论调用多少次，它都必须返回同一个整数。

2. 两个对象如果调用equals函数是相等的话，那么调用hashCode函数一定会返回相同的整数。

3. 两个对象如果调用equals函数是不相等的话，那么调用hashCode函数不要求一定返回不同的整数。

我们在改写equals 和 hashCode 函数的时候，一定要遵守如上3条约定，在改写equals的同时也改写hashCode的实现，这样才能保证得到正确的结果。

对象转型

（一种向上转型 一种向下转型）

一个基类的引用类型变量可以“指向”其子类的对象。

一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）

可以使用引用变量 instanceof 类名来判断该引用型 变量所“指向”的对象是否属于该或该类的子类。

子类的对象可以当作基类的对象业使用称作向上转型（upcasting）， 反之称这向下转型（downcasting）

多态

1 一定要有继承

2 一家要有重写

3 父类引用指向子类对象

抽象类

用abstract关键字来修饰一个类时，这个类叫体系抽象类;用abstract来修饰一个方法时，该方法叫做抽象方法。

含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须重写。

抽象类不能被 实例化。

抽象方法只需声明，而不需实现。

定义完抽象类后，就可以使用它。但是抽象类和普通类不同，抽象类不可以实例化。但是可以创建抽象类的对象变量，只是这个变量只能用来指向它的非抽象子类对象。

Public class UserAbstract

{

Public static void main(String[] args)

{

Animal animal1 = new Fish();  // Animail 是抽象类

animail1.brrath();

Animal animal2 = new Tiger();

animail2.breath();

}

}

需要注意的是，尽管animal存放的是tiger对象或是Fish对象，但是不能直接调用这些了类的方法，调用这项方法的时候仍然需要进行类型转换，正确的使用方法好下：

((Fish) animal1).swim();

((Tiger)animal2).tigerrun();

接口

接口是抽象方法和常量值的定义的集合

从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。

接口特性

接口中声明的属性默认为public static final的; 也只能是 public static final的;

接口中只能定义抽象方法，而且这些方法默认为public的、也只能是public的;

接口可以继承其它的接口，并添加新的属性和抽象方法。

例如：

Int i;  实际效果是： public static final i;

Public interfaice Animal

{

// 接口中的变量

Int BIG_TYPE = 5;

// 用接口声明方法，只有方法的声明没有具体实现

void sleep();

void eat();

void breath();

}

多个无关的类可以实现同一个接口

一个类可以继承多个无关的接口。

与继承关系类似，接口与实现类之间存在多态性。

例如：

Class 类名 implements 接口1， 接口2

{

方法1(){};

方法2(){};

}

要注意的地方：

1 如果实现接口的类不是抽象类，它必须实现接口中定义的所有的方法，如果该类为抽象类，在它的子类甚至子类的了类中要实现接口中定义的方法。

2 实现接口的方法时必须使用相同的方法名和参数列表。

3 实现接口类中的方法必须被声明为public.因为在接口中的方法都定义为public.根据继承接的原则，访问范围只能放大，不能缩小。

接口之间也呆以有继承继承接口的接口拥有它的父接口的方法，它还可以定义自己的方法，实现这个子接口的类。

接口的另一个重要应用是用它来创建常量组，例如要用int类型的一组数来表示星期，而且这些天都是固定不需要改变的，就可以通过接口来实现。

//用接口来存放变量

Interface Weekdays

{

Int MONDAY = 1;

Int TUESDAY = 2;

Int WEDNESDAY = 3;

Int THUESDAY = 4;

Int FRIDAY = 5;

Int SATURDAY = 6;

Int SUNDAY = 7;

}

抽象类和接口的区别

1、Java接口和Java抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以，这大概就是Java抽象类唯一的优点吧，但这个优点非常有用。

如 果向一个抽象类里加入一个新的具体方法时，那么它所有的子类都一下子ic都得到了这个新方法，而Java接口做不到这一点，如果向一个Java接口里加入一个 新方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每一个类都再实现这个方法才行，这显然是Java接口的缺点。

2、一个抽象类的实现只能由这个抽象类的子类给出，也就是说，这个实现处在抽象类所定义出的继承的等级结构中，而由于Java语言的单继承性，所以抽象类作为类型定义工具的效能大打折扣。

在这一点上，Java接口的优势就出来了，任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型，而一个类可以实现任意多个Java接口，从而这个类就有了多种类型。

3、从第2点不难看出，Java接口是定义混合类型的理想工具，混合类表明一个类不仅仅具有某个主类型的行为，而且具有其他的次要行为。

4、结合1、2点中抽象类和Java接口的各自优势，具精典的设计模式就出来了：声明类型的工作仍然由Java接口承担，但是同时给出一个Java 抽象类，且实现了这个接口，而其他同属于这个抽象类型的具体类可以选择实现这个Java接口，也可以选择继承这个抽象类，也就是说在层次结构中，Java 接口在最上面，然后紧跟着抽象类，哈，这下两个的最大优点都能发挥到极至了。这个模式就是“缺省适配模式”。

在Java语言API中用了这种模式，而且全都遵循一定的命名规范：Abstract ＋接口名。

Java接口和Java抽象类的存在就是为了用于具体类的实现和继承的，如果你准备写一个具体类去继承另一个具体类的话，那你的设计就有很大问题了。Java抽象类就是为了继承而存在的，它的抽象方法就是为了强制子类必须去实现的。

使用Java接口和抽象Java类进行变量的类型声明、参数是类型声明、方法的返还类型说明，以及数据类型的转换等。而不要用具体Java类进行变量的类型声明、参数是类型声明、方法的返还类型说明，以及数据类型的转换等。

内部类

内部类分为两在类。静态内部类和非静态内部类。非静态内部可以调用宿主类的所有变量和方法，并且像宿主类的其他非成员那样直接引用它们。静态内部类是用static修饰的类，静态内部不能直接访问其宿主类的成员，而必须通过对象来访问。

对于宿主类访问内部类的成员变量，静态内部类的静态变量可以直接用“类名.变量名”来调用，对于静态内部类的非静太变量则要生成它的对象，利用对象来访问。非静态内部类中不包含静态变量，所以必须用非内部类的对象来访问。

局部内部类

内部类不公可以在类中定义，也呆以在方法中定义。变量如果定义在类中，叫做成员变量；如果定义在方法中，叫做局部标量。内部类也是这样的，当定义在方法中时，叫做局部内部类。

对象克隆

****

最简单的例子：

public class HelloWorld{

public static void main(String args[]){

System.out.println("Hello World");

}

}

之所以给出这个例子是为让自己记住这个类名要和文件名一致.