对象的转型，抽象类，包的访问权限



对象的转型分为：向上转型和向下转型。 
一.对象的转型 
1.1什么是向上型转型？ 
向上转型—将子类的对象赋值给父类的引用。 
Student s = new Student(); 
Person p = s; 
 
具体看以下的代码： 
public class Person { 
String name; 
int age; 
void introduce(){ 
System.out.println(“姓名：”+name+”年龄：”+age); 
} 
} 
public class Student extends Person{ 
String address; 
void study(){ 
System.out.println(“我正在学习”); 
} 
void introduce(){ 
super.introduce(); 
System.out.println(“我的家在：”+address); 
} 
} 
/* 
一个引用能够调用哪一个方法，取决于这个引用所指向的对象； 
一个引用能够调用哪些成员变量和成员函数，取决于这个引用的类型； 
/ 
public class Test { 
public static void main(String[] args) { 
Student s = new Student(); 
Person p = s; 
p.name= “Jack”; 
p.age =20; 
// p.address = “北京”;//p的引用只能调用父类中的所涵盖的成员变量 
//p.study();//在父类中无study方法体； 
p.introduce(); 
// System.out.println(“姓名是：”+name+”年龄是：”+age); 
} 
} 
1.2向下转型 
向下转型 —将父类的对象赋值给子类的引用； 
前提是：首先进行向上转型(将一个对象向上转型为Person) 
Student s1 = new Student(); 
Person p = s1;//将子类的对象赋值给父类的引用; 
Student s2 = (Student)p;//将Person类型向下转型为Student类型； 
 
错误的向下转型： 
Person p = new Person(); 
Student s = (student)p; 
正确的向下转型： 
Person p = new Student(); 
Student s = (student)p; 
二.抽象类和抽象函数 
2.1什么是抽象函数？ 
顾名思义就是：只有函数的定义，没有函数体的函数。 
abstract void fun();//无函数体 
函数定义(返回值，参数列表，函数名) 
在一个类中，如果一个类中拥有一个或者一个以上的抽象函数，那么这个类也必须被定义为抽象类。 
public abstract class Worker { 
String name; 
int age ; 
void introduce(){ 
System.out.println(“名字是：”+name+”年龄是：”+age)； 
} 
abstract void eat(); 
} 
2.2什么是抽象类？ 
顾名思义就是：使用abstract定义的类被称之为抽象类。 
需注意以下几点： 
a.抽象类不能够生成对象；(抽象类自身不能产生对象，而抽象类的子类可以生成对象) 
b.如果一个类中包含有抽象函数，那么这个类也必须被声明为抽象类；(若子类在继承过程中，父类中有抽系那个函数，则子类也应声明为抽象类) 
c.如果一个类中没有抽象函数，那么这个类也可以被声明为抽象类； 
2.3抽象类是否可以有构造函数？ 
需满足这两个条件：抽象类不能生成对象；构造函数用于生成类的对象。 
实质上抽象类可以有构造函数，在生成子类对象的时候被调用。 
a.抽象函数就是没有函数体的函数； 
b.抽象类使用abstract来定义； 
c.抽象类不能生成对象，但是确可以拥有构造函数； 
三包的访问权限 
3.1包的作用： 
<1>把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用； 
<2>如同文件夹一样，包也采用了树形目录 的存储方式。同一个包中的类名是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。 
<3>包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。 
/将类放置到一个包中，需要使用package”包名” 
编译时需要使用-d 参数，该参数的作用是依照包名生成相应的文件夹 
一个类的全名应该是”包名”+.”类名” 
/mars.Test 
包名的命名规范； 
1.要求包名所有的字母都要小写； 
2.包名一般情况下，是你的域名倒过来写 
marsdroid.org,package org.marsdriod 
凡是多了一个.相当于多了一个目录 
/ 
package org.marsdrioid.user; 
public class Person1 { 
public static void main(String[] args) { 
System.out.println(“打包”); 
} 
} 
3.2包的访问权限 
public：公有权限，可以修饰类，成员变量，成员函数，适用于跨包的场合中。(若类名被声明为public类型，则要求类名和原文件名需要一致），其代码如下： 
//如果类名被声明为public,则要求类名和原文件名需要一致 
package org.marsdroid; 
class Person{ 
public String name; 
public int age; 
public void introduce(){ 
System.out.println(name); 
} 
} 
package org.marsdroid; 
import org.marsdroid.Person;//也可以添加通用符. 
class Test{ 
public static void main(String args[]){ 
/Person p = null;/ 
org.marsdroid.Person p = new org.marsdroid.Person();//由于Person和Test不在一个包名中，所以在Person时必须是”包名”+”类名 ” 
//p.name = “zhangsan”在一个包的外部想要调用一个成员变量和成员函数，要求这个变量和函数都是public权限。 
p.age = 10;//若在同一个包中，包名可以省略; 
} 
} 
private:私有权限，修饰成员变量和成员函数；只能在本类中使用(前提是将成员变量和成员函数声明为private)，在其他包中不能使用。 
package org.marsdroid; 
class Person{ 
private String name; 
private int age; 
private void introduce(){ 
System.out.println(name); 
} 
} 
package org.marsdroid; 
class Test{ 
public static void main(String args[]){ 
Person p = new Person(); 
//p.name = “Rose”;//因为name成员变量的访问权限为私有的，即使两个类在同一个包中，也不可以访问； 
} 
} 
default：包级别的访问权限。(不写权限修饰符，就是default权限)，可以修饰类，成员变量和成员函数。作用域是声明的包范围，不能跨包调用。 
protected:受保护的权限，其权限允许在本类，或者是同包中的其他类或者是子类。 
3.3访问权限的继承 
package com.marsdroid; 
//package org.marsdroid; 
public class Person{ 
protected String name; 
protected int age; 
void eat(){ 
System.out.println(“吃饭”); 
} 
void sleep(){ 
System.out.println(“睡觉”); 
} 
} 
package org.marsdroid; 
import com.marsdroid.Person; 
class Student extends Person{ 
void introduce(){ 
System.out.println(“我的名字是” + name +”我的年龄是” + age); 
}

} 
class Test{ 
public static void main(String args[])}{ 
Student student = new student(); 
student.name = “lisa”; 
student.age = 18; 
student.introduce();//student继承了父类的一些成员变量和成员函数，减少了重复代码，因为如果不利用继承的关系，在student这个类中会出现重复代码； 
} 
} 
简单总结一下访问权限： 
要在一个包中使用另外一个包中的类，需要进行导入; 
如果一个类不是公共的，那么在这个类所在的包的外部使用这个类，要想在另外一个包中继承Person,那么Person必须是public类型的; 
如果子类和父类不在同一个包中，子类可以继承父类当中的default权限的成员变量和成员函数，但是由于权限不够，无法使用。使用default权限内容的前提是两个类必须在同一个包中; 
protected权限首先拥有default一样的功能，但是该权限只能修饰成员变量和成员函数，允许跨包的继承。即使子类和父类不在同一个包中 ; 
子类和父类不在同一个包中，子类可以调用父类中Protected权限的成员变量和成员函数； 
如果两个类没有关系，此时不同包只能访问类中的public类型的变量。 
访问权限的大小：public >protected>default>private 
public :即使两个类不在一个包中 ，没有关系，仍然可以访问; 
protected权限允许子类和父类在不同的包中，子类可以使用父类中的protected权限的成员变量和成员函数; 
default 允许在同一个包中访问; 
private只能在本类中使用; 
一个类的权限尽量小，这样才能体现出面向对象的封装性;