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类型的。
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");
}
}
之所以给出这个例子是为让自己记住这个类名要和文件名一致.