java 基础_移动开发_编程开发_程序员俱乐部

中国优秀的程序员网站程序员频道CXYCLUB技术地图
热搜:
更多>>
 
您所在的位置: 程序员俱乐部 > 编程开发 > 移动开发 > java 基础

java 基础

 2013/10/17 15:13:59  Sherwin_  博客园  我要评论(0)
  • 摘要:一4类8种基本数据类型逻辑型-boolean文本型-char整数型-byteshortintlong浮点数型-floatdouble☆java各整数类型有固定的表数范围和字段长度,其不受具体操作系统的影响以保证java程序的可移植性。☆java语言的整型常量默认为int型,声明long型常量后可以加‘l’或‘L’.☆java浮点类型常量默认为double型,如要声明一个常量用float型,则要在数字后面加f或F
  • 标签:Java

class="p0">一 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类型的。

 

1final类 

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

 

2final方法 

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

 

使用final方法的原因有二: 

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

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

 

3final变量(常量) 

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

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

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

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

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

4final参数 
当函数参数为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定义的变量是类变量。两者的区别是:

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

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

 

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

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

静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量和静态方法),而不允许访问实例成员变量和实例方法;实例方法则无此限制。

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

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

packageimport语句

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

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

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语言的核心类,如StringMathIntegerSystemThread,提供常用功能

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基类的变量和方法。其他的都可以。

★子类和父类不在同一包中的继承性:继承protectedpublic基类的变量和方法

 

方法的重写

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

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

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

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

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

 

成员变量的隐藏

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

 

关键字 super

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

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

 

继承中的构造方法

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

子类可以在自己的构造方法中作用superargumnet_list)调用基类的构造方法。

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

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

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

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

 

Object

Object是所有java类的根基类

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

Public class Persom {

  ……

}

等价于:

Public class persom extends Object {

……

}

 

Object类中的hashCodeequals函数有着非常紧密的逻辑关系。当然这个逻辑关系是人赋予它的。在没有覆盖这两函数函数之前,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”,只要xy内容一直不变,不管你重复x.equals(y)多少次,返回都是“true”。

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

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

如果x.equals(y)返回“true”,那么xyhashCode()必须相等。

如果x.equals(y)返回“false”,那么xyhashCode()有可能相等,也有可能不等。

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

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

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

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

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

 

对象转型

(一种向上转型 一种向下转型)

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

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

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

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

 

多态

一定要有继承

一家要有重写

父类引用指向子类对象

 

抽象类

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(){};

}

要注意的地方:

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

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

实现接口类中的方法必须被声明为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;

}

 

抽象类和接口的区别

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

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

 

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

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

 

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

 

4结合12点中抽象类和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");

    }

}

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

发表评论
用户名: 匿名