------- http://www.itheima.com" target="blank">android培训http://www.itheima.com"target="blank">java培训、期待与您交流!
一.、构造方法:
1.当实例化一个类的对象时,JVM会自动调用本类的一个方法:构造方法;
2.定义类时,可以不定义构造方法,编译器会自动添加一个无参的构造方法;
3.如果类中定义了构造方法,编译器就不会添加任何构造方法了;
4.构造方法的格式要求:
1).构造方法名必须与类名一致;
2).构造方法不能定义“返回值类型”,甚至是void;
3).构造方法不能返回一个具体的值,但内部可以使用return;语句;
注意:
1).以下代码可以编译通过:
class Student(){
public void Student(){ //普通成员方法,不是构造方法;
}
}
2).以下代码不能通过编译:
class Student(){
public student(){ //构造方法必须同类名一致,包括大小写;
}
}
5.一个类中可以定义多个“构造方法”,但每个构造方法的形参列表不能完全相同,叫:构造方法的重载;
6.在一个构造方法中可以调用另一个构造方法,使用this关键字;
7.构造方法可以调用“成员方法”,但“成员方法”不能调用构造方法;
二、static关键字:
1.static关键字:静态的,全局的。
2.可以修饰“成员变量”和“成员方法”。被static修饰的成员变量存储在方法区的“静态存储区”,只有一份拷贝,被多个对象共享;
3.特点:
1).随着类的加载而加载
2).优先于对象存在
3).被类的所有对象共享
4).可以通过类名调用,也可以通过对象名调用;
4.static关键字注意事项:
1).在静态方法中是没有this关键字的
2).静态方法只能访问静态的成员变量和静态的成员方法
三、静态变量和成员变量的区别:
1.所属不同
1).静态变量属于类,所以也称为为类变量
2).成员变量属于对象,所以也称为实例变量(对象变量)
2.内存中位置不同
1).静态变量存储于方法区的静态区
2).成员变量存储于堆内存
3.内存出现时间不同
1).静态变量随着类的加载而加载,随着类的消失而消失
2).成员变量随着对象的创建而存在,随着对象的消失而消失
4.调用不同
1).静态变量可以通过类名调用,也可以通过对象调用
2).成员变量只能通过对象名调用
四、继承:
1.继承的关键字:extends
2.作用:提高了代码的复用性。为多态提供了前提;
3.this和super的区别:
1).this:
1).在任何类中使用;
2).存储的是本类对象的引用;
3).可以访问本对象的成员变量、成员方法、构造方法;
2).super:
1).在子类中使用;
2).存储的是父类对象的引用;
3).可以访问父类对象的成员变量、成员方法、构造方法;
4.类的初始化过程:
加载class文件
堆中开辟空间
变量的默认初始化
变量的显示初始化
构造代码块初始化
构造方法初始化
成员变量-->构造代码块-->构造方法
5.Java中继承的特点:
1).Java中只能单继承;
2).Java中可以多级继承;
6.继承的好处和弊端:
好处:1).代码复用 2).为多态提供了前提;
弊端:1).由于继承,子类对父类产生了依赖;
五、方法重写:
1.在子类中,定义跟父类一模一样的方法,这叫:方法重写;
2.重写的规则:
1).返回值类型、方法名、形参列表:要完全一致;
2).子类的访问修饰符可以跟父类的相同,或更宽;
3.重写的意义:
1).子类保留了父类的方法,具有了自己特有的行为;
4.重写和重载的区别:
1).重写:在子类中定义跟父类一模一样的方法;
2).重载:在一个类中,定义:方法名相同,参数列表不完全相同的方法,叫:重载。跟返回值类型无关;
六、final关键字:
1.可以修饰:
成员变量:表示其变量拥有最终的值,不能被更改,成为"常量"。修饰基本数据类型:表示其值不能被修改。修饰引用数据类型,表示地址不能被修改;
成员方法:表示最终的方法。不能被重写;
类: 表示最终类。不能被继承;
局部变量:表示其值不能改变;区分:基本类型和引用类型;
方法形参:表示其值不能改变;区分:基本类型和引用类型;
七、多态:
1.父类的引用指向子类的对象;
2.多态前提和体现
1).有继承关系
2).有方法重写
3).有父类引用指向子类对象
3.多态的转型:
1).自动转型:子类的引用转为父类的引用;Person p = new Student();
2).强制转型:父类的引用转为它所指向的子类对象的引用;Student stu = (Student)p;
3).在进行强制转型前,为保证安全,可以使用instanceof关键字进行判断:
if(p instanceof Student){
Student stu = (Student)p;
}
4.多态的好处:
1).提高了程序的维护性(由继承保证)
2).提高了程序的扩展性(由多态保证)
5.多态的弊端:
1).不能访问子类特有功能(可以向下转型)
6.多态时的访问规则:
1).总体规则:访问的任何成员父类中必须要有,否则编译错误;
例如:
class A{
int num = 10;
}
class B extends A{
int n = 20;
}
main(){
A a = new B();
System.out.println(a.n); //编译错误,父类中没有n
}
2).成员变量:如果子、父类中都有,访问的是“父类”的;
class A{
int num = 10;
}
class B extends A {
int num = 20;
}
main(){
A a = new B(); //多态
System.out.println(a.num); //打印10;
}
普通方法:如果子、父类中都有(重写),访问的是“子类”的;
class A{
void show(){
System.out.println("A-->show()");
}
}
class B extends A{
void show(){
System.out.println("B-->show()");
}
}
main(){
A a = new B();
a.show(); //打印:B-->show()(访问的是子类的show());
}
静态方法:如果子、父类中都有(重写),访问的是“父类”的;
八、抽象类:
1.使用abstract关键字修饰;可以修饰“类”,可以修饰“成员方法”;
abstract class A{
abstract void show();
}
2.“抽象类”的特点:
1).不能被实例化,只能用于被继承;
2).可以包含:成员变量、构造方法、成员方法、抽象方法;
3).可以不包含抽象方法;
3.“抽象方法”的特点:
1).没有方法体;abstract void show();
2).必须被子类重写。除非子类也是个抽象类;
3.子类继承抽象类使用关键字:extends,仍然是单继承;
4.一个子类继承 了一个抽象类,必须实现抽象类中所有的抽象方法;
否则子类也必须是抽象的。
例如:
abstract class A{
abstract void show();
}
class B extends A{ } //编译错误。类B不是抽象的,继承类抽象类必须重写抽象类中的所有抽象方法。
abstract class B extends A{ } //编译通过。类B没有重写父类中的抽象方法,但类B是抽象的。
5.abstract关键字不能和哪些关键字共存:
1).private:抽象方法就是用来被子类重写的,而私有方法不能被子类重写;
2).final:抽象类和抽象方法就是用来被子类继承和重写的,而final类和final方法不能
被继承和重写;
3).static:static修饰的方法在没有任何对象的情况下就会被分配内存空间;而抽象方法
没有方法体,无法分配空间;
九、接口:
1.使用interface关键字定义:只能修饰“类”:
interface IA{
}
2.“接口”的特点:
1).不能被实例化,没有构造方法,只能用于子类“实现”;
2).可以包含:
A.成员变量(常量):隐式的定义为:public static final。
上述三个关键字中任何一个都可以不写,系统会自动添加;
例如:
interface IA{
public int num1 = 10; //OK
static final int num2 = 20; //OK
final int num3 = 30; //OK
public final num4 = 40; //OK
int num5 = 50; //OK
}
B.抽象方法:隐式的定义为:public abstract。可以省略,系统会自动添加
例如:
interface IA{
void show1(); //OK
public void show2(); //OK;
abstract void show3(); //OK;
}
3).接口的功能是:扩展功能;
3.子类实现接口使用关键字:implements
4.一个子类可以同时实现多个接口;
interface IA{}
interface IB{}
class C implements IA,IB{ //OK的。
}
5.子类实现接口时,必须重写接口中所有的抽象方法,而且必须是public的--因为接口中抽象方法的定义隐式的是public的。
例如:
interface IA{
void show();
}
class B implements IA{
void show(){ } //编译错误。父接口的show()隐式的为public的,子类重写时必须是public的;
}
6.接口编译后一样会生成.class文件。
十、类与类,类与接口,接口与接口的关系:
1.类与类:继承关系,关键字:extends ,只能单继承,但是可以多层继承
2.类与接口:实现关系,关键字:implements ,可以单实现,也可以多实现。还可以在继承一个类的同时实现多个接口
3.接口与接口:继承关系,关键字:extends,可以单继承,也可以多继承
例如:
interface IA{}
interface IB{}
interface IC extends IA,IB{} //OK的
十一、抽象类和接口的区别:
1.成员区别
1).抽象类 变量,常量;有抽象方法;非抽象方法
2).接口 常量;抽象方法
2.关系区别
1).类与类 继承,单继承
2).类与接口 实现,单实现,多实现
3).接口与接口 继承,单继承,多继承
3.设计理念区别
1).抽象类 被继承体现的是:”is a”的关系。共性功能
2).接口 被实现体现的是:”like a”的关系。扩展功能
十二、包:
1.定义包使用关键字:package;
1).注意事项:
A.package语句必须是程序的第一条可执行的代码
B.package语句在一个java文件中只能有一个
C.如果没有package,默认表示无包名
2.导入包使用关键字:import;
1).注意事项:
A.导入到最终的类;
B.可以使用通配符:*,只统配包下的类,不包括子包下的其它类;
C.在一个类文件中,可以有多条import语句;
D.import语句必须在package语句之后,在定义类之前;
3.package,import,class有没有顺序关系?
有:package-->import-->class
十三、访问修饰符:
1.用于限定“类”和“成员”被其它包下的其它类访问的;
2.四种访问修饰符:
1).public(公有):可以修饰类、成员。可以被任何包下的其它类访问;
2).protected(保护):可以修饰成员。可以被同包下的其它类访问。如果在包外
只能被子类访问;
3).(默认):可以修饰类、成员。只能被包内的其它类访问;
4).private(私有):可以修饰成员。只能被类中的其它方法访问;
3.类及成员可用的修饰符:
1).类:
默认,public,final,abstract
我们自己定义:public居多
2).成员变量:
四种权限修饰符均可,final,static
我们自己定义:private居多
3).构造方法:
四种权限修饰符均可,其他不可
我们自己定义:public 居多
4).成员方法:
四种权限修饰符均可,fianl,static,abstract
我们自己定义:public居多
十四、内部类:
1.成员内部类:
1).定义在类体中,作为类的成员;
2).可以使用同类“成员方法”相同的修饰符;
2.局部内部类:
1).定义在某个方法或代码块内部;
2).不能使用“访问修饰符”,不能使用static修饰符;可以使用final和abstract
3).注意:局部内部类访问“局部变量”,要求局部变量必须是final的(常量);
3.匿名内部类:
1).就是内部类的简化写法。
2).前提:存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
3).格式:
new 类名或者接口名() {重写方法;}
4).本质:
是一个继承了类或者实现了接口的子类匿名对象