1. Java的访问控制修饰符
访问修饰控制符:
有3种访问修饰符:public、private、protected。
以及不使用关键字的默认访问权限(包访问权限)
访问权限:
package com.resource;
class SomeVar {
public String varPublic = "Public";
protected String varProtected = "Protected";
private String varPrivate = "Private";
}
public class SamePack {
public static void main(String[] args){
SomeVar sv = new SomeVar();
System.out.println(sv.varPublic); // 无报错
System.out.println(sv.varProtected); // 无报错
System.out.println(sv.varPrivate); // The field SomeVar.varPrivate is not visible
}
}
//这里会在引用varPrivate变量时报错,表明private修饰的变量无法被包内其他的类访问,只能被本类访问。
package com.run;
import com.resource.SomeVar;
public class RunVar {
public static void main(String[] args){
SomeVar sv = new SomeVar();
System.out.println(sv.varPublic); // 无报错
System.out.println(sv.varProtected); // The field SomeVar.varProtected is not visible
System.out.println(sv.varPrivate); // The field SomeVar.varPrivate is not visible
}
}
//由于RunVar类与SomeVar类不在同一个包内,所以其不能访问SomeVar类的varProtected与varPrivate属性。
2. 子类对于父类的继承
子类继承了父类的所有属性和方法, 但只有public、protected的属性和方法在子类中是可见的,private修饰的属性和方法仅对父类可见。
class FatherPlane{
public String namePub = "Public name";
protected String namePro = "Protected name";
private String namePri = "Private name";
}
class SonPlane extends FatherPlane{
public void setName(String name_){
this.namePri = "new private"; // The field FatherPlane.namePri is not visible
}
}
public class RunPlane{
public static void main(String args[]) {
SonPlane sp = new SonPlane();
System.out.println(sp.namePub); // 无报错
System.out.println(sp.namePro); // 无报错
System.out.println(sp.namePri); // The field FatherPlane.namePri is not visible
}
}
3. 组合
组合的概念:组合就是在一个类里面使用已经定义好的类对象的引用,并通过发消息的形式调用该对象的属性和方法。
组合的作用:组合不会破坏旧类的封装,整体类与局部类之间松耦合,独立性强,非常灵活,也无需担心继承所带来的一系列权限问题。
class FighterPlane
{
String name;
int missileNum;
public FighterPlane(String _name,int _missileNum){
name = _name;
missileNum = _missileNum;
}
public void fire(){
if (missileNum>0){
System.out.println("now fire a missile !");
missileNum -= 1;
}
else{
System.out.println("No missile left !");
}
}
}
class A
{
FighterPlane fp;
public A(FighterPlane fpp){
this.fp = fpp; //A对象中拥有了FighterPlane对象的引用
}
public void invoke(){
//A中对象发送消息给FighterPlane的对象
System.out.println(fp.name);
}
}
public class Run{
public static void main(String[] args)
{
FighterPlane ftp = new FighterPlane("su35",10);
//产生A对象,并将ftp对象引用作为参数传入
A a = new A(ftp);
//发送消息,产生调用关系
a.invoke();
}
4.重载与覆写
重载
重载(overload)的概念:指的是同一个类中参数个数和类型不同但方法名相同的多个方法,返回类型可以相同也可以不同。调用时,会根据不同的参数表选择对应的方法。
重载的作用:重载可以使得同一个方法处理不同类型的参数并返回不同类型的值,虽然参数不同但这些同名方法所实现的作用是相同的,是实现多态的非常重要的机制。
class StuManage {
public int getScore(){
return 3;
}
public int getScore(int i){
return i;
}
/*public long getScore(int i){
return i;
}*/
/*private int getScore(int i){
return i;
}*/
/*public static int getScore(int i){
return i;
}*/
/*public final int getScore(int i){
return i;
}*/
public int getScore(Integer i){
return i;
}
//可变参数,i实质上是数组int[]
public int getScore(int ... i){
return 3;
}
}
覆写
覆写(overriding)的概念:覆写指的是子类对父类中已经定义好的方法进行了重新定义,方法名、返回值类型和形式参数都不能改变。
覆写的作用:使得子类能够灵活的根据自己的需要修改父类中所定义的方法,而无需修改父类中的方法。
class Parent {
Number getScore(int a) {
return new Integer(7);
}
}
class Son extends Parent {
@Override //所有的覆写方法需注明
Number getScore(int b){
return new Integer(8);
}
}
public class RunSon{
public static void main(String args[]){
Son s = new Son();
System.out.println(s.getScore());
}
}
覆写与重载的区别:
覆写:方法名称相同,参数类型、个数一致,子类返回类型可向上转型到父类返回类型 (类族)
重载:方法名称相同,参数类型或个数不同 (同一个类)