Java面向对象语言的特征:封装,继承,多态
封装
封装的好处:
- 提高了代码的复用性
- 隐藏了实现细节,还要对外提供可以访问的方式,便于调用者的使用,这也是封装的概念
- 提高了安全性
方法就是 一个基本封装体,类也是一个封装体
private 关键字:private (私有) 属于成员修饰符,不能修饰局部变量,被private修饰的成员,只能在自己的本类中使用
作用:提高安全性:让外面的类,不能直接调用本类的成员变量
对被私有的成员变量,可以提供公共的访问方式,即 get 和 set 方法,让外面的类可以使用
this 关键字:用于区分同名的成员变量和局部变量,局部变量和成员变量同名时,方法中会采取就近原则,访问局部变量,要访问成员变量,用 this 关键字,使用格式:this . 成员变量 ;
public class Person {
private String name;
public void setName(String name) { //set方法
this.name = name;
}
public String getName() { //get方法
return name;
}
public void speak() {
// 局部变量和成员变量同名,会采取就近原则,访问局部变量
String name = "大大";
// 方法中,要访问成员变量,写this
System.out.println("成员变量:"+this.name);
System.out.println("局部变量:"+name);
}
}
import cn.itcast.demo05.Person; //导入上面Person类所在的包
public class PersonTest {
public static void main(String[] args) {
Person p = new Person(); //定义Person类的对象
p.setName("小小"); //调用类中的set方法为对象的私有成员变量赋值
p.speak(); //调用类中的方法speak
System.out.println(p.getName());
//调用类中的get方法得到对象的私有成员变量的值
}
}
输出:第一行:成员变量:小小 第二行:局部变量:大大 第三行:小小
继承
类之间可以有继承关系,被继承类叫做父类,继承它的类叫子类,在程序中,如果想声明一个类继承另一个类,需使用 extends 关键字
使用格式:calss 子类 extends 父类 { ...... }
继承注意事项:
- 一个类只能拥有一个父类(单继承)
- 一个类可以拥有多个子类
- 可以多层继承(例如B类继承A类,C类继承B类)
多层继承时,以B类继承A类,C类继承B类为例,如果A,B类中有相同的方法,那么C类的对象在调用这个方法时,使用的是B类的方法
当子类和父类中出现了同名变量时,如果要在子类中访问父类的这个变量,需使用 super 关键字,来表示当前对象中包含的父类对象空间的引用,使用格式:super . 变量名
public class Fu {
int i=1;
}
public class Zi extends Fu {
int i=2;
public void show1() {
System.out.println(i); // 这里i=2
}
public void show2() {
int i=3;
System.out.print(i+"\t"); // 这里i=3(就近访问)
System.out.print(this.i+"\t"); // 这里i=2
System.out.println(super.i); // 这里i=1,前提是父类中变量i没有被私有
}
}
public class Test {
public static void main(String[] args) {
Zi z = new Zi();
System.out.println(z.i); //i = 2
z.show1();
z.show2();
}
}
输出:第一行:2 第二行:2 第三行:3 2 1
抽象类
关键字 abstract :抽象类的定义:class abstract 类名{ },在抽象类中可以定义抽象方法,就是没有方法体的方法,抽象方法的定义:public abstract 返回值类型 函数名(参数列表); 注意:没有函数体!
抽象类不能创建对象,所以要一个子类继承中国抽象类,并重写每个抽象方法,才可以创建子类对象,如果子类继承了抽象类,没有重写每一个抽象方法,那么这个子类依然是一个抽象类。抽象方法不能被私有。
接口
接口是功能的集合,接口中,只有功能的定义,没有实现,接口的定义:用关键字 interface :public interface {......}
注意:接口中方法的定义:权限只能是public;接口中成员变量定义的标准格式:public static final 类型 变量名 = 值 ;
类实现接口
使用关键字 implements:就是定义一个类,重写接口中的各抽象方法,格式:class 类名 implements 接口名{重写接口中的抽象方法}
一个类可以实现多个接口,要求重写所有抽象方法,才能创建类的对象,否则这个类还是一个抽象类,并且必须有public权限;另外,接口与接口之间可以多继承
public interface A { //定义接口A
public abstract void fun();
}
public interface B { //定义接口B
public abstract void fun();
}
public abstract class C { //定义抽象类C
public abstract void c();
}
public class D extends C implements A,B { //类D继承抽象类C并同时实现接口A,B
public void fun() {
} // 没有安全隐患
public void c() {
}
}
//之后就可以在主方法中创建D类的对象了
多态
public class abstract Fu {......}
public class Zi extends Fu {......}
public interface Smoking{......}
public class Person implements Smoking {......}
public static void main(String[] args) {
//向上转型
Fu f = new Zi(); //抽象类定义的多态格式
Smoking s = new Person(); //接口定义的多态格式
//向下转型
Zi z = (Zi)f;
Person p = (Person)s;
}
多态中成员特点:
成员变量: 编译时,参考父类中有没有这个变量,有就编译成功,没有则失败
运行时,用的是父类中的变量值
编译运行全看父类
成员方法:编译时,参考父类中有没有这个方法,有就编译成功,没有则失败
运行时,用的是子类的重写方法
编译看父类,运行先看子类,子类没有看父类
关键字:instanceof,比较运算符,结果为真假值,用于比较一个引用类型的对象,是不是这个类型的对象,可以防止发生异常,比如:
public calss Fu{...}
public class Zi1 extends Fu{...}
public class Zi2 extends Fu{...}
public static void main(String[] args) {
Fu f1 = new Zi1();
Fu f2 = new Zi2();
if(f1 instanceof Zi1) { //f1 instanceof Zi1 值为true
Zi1 z1 = (Zi1)f1;
}
if(f2 instanceof Zi1) { //f2 instanceof Zi1 值为false
Zi1 z2 = (Zi1)f2;
}
}
注意:如果A类和B类之间没有继承关系,A a = new A(); boolean bool = a instanceof B;这句就会报错,不能这样使用!
向上转型创建的对象,可以调用子类和父类的共有成员,但是不能调用子类的特有成员
类型的向下转型,强制转换,可以让创建的对象调用子类的特有成员