null主讲教师: 李青
TEL: 15895982720
Email: LKJ0986@sina.com.cn
数学与信息技术学院主讲教师: 李青
TEL: 15895982720
Email: LKJ0986@sina.com.cn
数学与信息技术学院JAVA编程第三章第三章类和对象回顾回顾Java 具有8种基本数据类型：int、boolean、char、short、long、float 及 double
Java 中的运算符可划分为四大子集：算术运算符、位运算符、关系运算符、逻辑运算符
Java 支持下列控制结构：选择、循环、跳转
数组可用来将同一类型的数据存储在连续的内存位置目标目标
面向对象程序MATCH_
word
word文档格式规范word作业纸小票打印word模板word简历模板免费word简历
_1713988190332_1基础
类和对象
类的封装性
类的继承性
类的多态性 面向对象编程面向对象编程用客观世界中描述事物的方法来描述程序中要解决的问
题
快递公司问题件快递公司问题件货款处理关于圆的周长面积重点题型关于解方程组的题及答案关于南海问题
程序便是成堆的对象，彼此通过消息的传递，请求其他对象进行工作
类和对象1类和对象1对象表示现实世界中某个具体的事物。
对象具有两方面的含义：
在现实世界中：
是客观世界中的一个实体
在计算机世界中：
是一个可标识的存储区域
抽象是从特定的实例中抽取共同的性质以形成一般化概念的过程。其结果产生类（型）。类和对象 2类和对象 2类是具有共同属性和行为的对象的抽象。
类可以定义为数据和方法的集合。
类也称为模板，因为它们提供了对象的基本框架。数据或变量方法类对象抽象实例化属性或状态操作或行为封装的实体=数据+方法访问对象访问对象访问格式： 对象名.成员变量(方法）；
例如：设有一个A类其结构如下：
class A {
int x;
void setX（）；
}
要对变量x赋值。
先创建并实例化类A的对象a
然后再通过对象给变量x：
A a = new A();
a.x=5; 设计一个学生类。想想学生的共性。
要求
对教师党员的评价套管和固井爆破片与爆破装置仓库管理基本要求三甲医院都需要复审吗
有姓名，学号，并能够输出姓名学号。设计一个学生类。想想学生的共性。
要求有姓名，学号，并能够输出姓名学号。class Student{
String Stu_name;
String Stu_num;
Public void getName(){ return Stu_name;}
Public void getNum(){ return Stu_num;}
}Student stu1=new student();
Stu1. Stu_name=“TOM”;
Stu1. Stu_num=“001”;
string sid=stu1.getNum();
定义一个学生，学号001，姓名TOM。询问TOM的学号。面向对象的三个基本特征面向对象的三个基本特征封装
继承
多态
面向对象的三个基本特征面向对象的三个基本特征封装性
对象本身的数据得到保护/隐藏
其他对象仅仅需要知道对该对象的访问方法即可
好处
模块化--每个对象的源文件可以是相互独立的，可以被不同的程序调用，每个对象是一块积木，可以搭建不同的形状
信息隐藏--通常定义一个公共接口/方法实现对对象的访问，可以调整对象的私有信息和方法，而不会对其他调用它的对象产生影响
可重用性
面向对象的三个基本特征面向对象的三个基本特征继承性
面向对象编程语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”。
被继承的类称为“基类”、“父类”或“超类”。
继承的过程，就是从一般到特殊的过程。
面向对象的三个基本特征面向对象的三个基本特征继承性
在使用继承时需要注意，那就是两个类之间的关系应该是“属于”关系。面向对象的三个基本特征面向对象的三个基本特征继承性
多重继承
Java中仅仅支持单一继承，同时Java采用Interface(接口)
实现多重继承面向对象的三个基本特征面向对象的三个基本特征多态性
多态性是允许将父对象设置成为和一个或更多的子对象相等的技术。
简单的说，允许将子类类型的引用赋值给父类类型的引用。
表现在继承中方法的覆盖，指子类重新定义父类的方法。
表现在用一个类中方法的重载，指允许存在多个同名方法，而这些方法的参数表不同(或许参数个数不同，或许参数类型不同，或许两者都不同)。
重载的实现是：编译器根据方法不同的参数表，对同名方法的名称做修饰，然后这些同名方法就成了不同的方法类的定义 类的定义 系统定义的类
用户自定义的类类的定义类的定义类的定义格式
[类的修饰符]class 类名 [extends 父类名] implements[接口名] {
类型 成员变量1;
类型 成员变量2;
… … … … … …
类型 成员方法1(参数1, [参数2, …]) {
方法体;
}
类型 成员方法2(参数1, [参数2, …]) {
方法体;
}
… … … … … …
}类的定义类的定义[类的修饰符] class 类名 [extends 父类名] [implements 接口名] { … … … … … …
}
类的修饰符
public: 公共类，可以被其他类所使用，(无任何限制)。
无修饰: 仅仅能在同一个包中的其他类引用
abstract: 该类不能被实例化
final：该类不能有子类
private：该类只能被该类的方法访问和修改，而不能被其它任何类访问，包括该类的子类也不能访问。null类的定义类的定义[类的修饰符] class 类名 [extends 父类名] [implements 接口名] {
… … … … … …
}
extends: 继承的关系
implements: 实现哪些接口(interface)的方法，实现多重继承
例：
public class Test extends Frame
implements ActionListener, ItemListener {
… … … …
}
一个简单的类一个简单的类class Student {
String Stu_name, Stu_number;
double score1, score2, score3;
void setStudent(String s1, String s2) {
Stu_name = s1; Stu_number = s2;
System.out.println(Stu_name + “ “ + Stu_number);
}
double setScore(double d1, double d2, double d3) {
double d;
score1 = d1;
score2 = d2;
score3 = d3;
d = d1 + d2 + d3;
return d;
}
}
JavaExample.javaJavaExample.javaimport Java.awt.*;
import Java.applet.Applet;
public class JavaExample extends Applet
{
String a = "Hello Java"; //数据成员a，类型为String
public void paint(Graphics g) //方法paint()
{
g.drawString(a, 100, 100);
}
}类的使用类的使用对象的声明
为对象分配内存空间
赋初值
数据成员和成员方法的使用 数据成员和成员方法的使用 对象的数据成员的引用：
对象名.数据成员名;
对象的成员方法的引用：
对象名.成员方法名（参数表）; nullclass car{
//数据成员（也可称为成员属性）
public String Name;
public char Color;
protected int Style;
//成员方法
public String getName(){
return Name;
}
public char getColor(){
return Color;
}
public int getStyle(){
return Style;
}
}
定义一个汽车类， 属性:名称、色彩、型号
方法：输出名称、色彩、型号null程序运行结果：
Color of car1:R
Style of car2:2测试类：创建car类的两个对象car1和car2类成员的访问权限修饰符 类成员的访问权限修饰符 访问控制修饰符
公共访问控制符－public
被所有类访问
默认访问控制符
被同一包中其他类访问
私有访问控制符－ private
被该类自身访问
保护访问控制符－ protected
该类自身、同一个包中的其他类、其他包中的子类访问
类的封装性简单访问控制 - private 和 public简单访问控制 - private 和 publicpublic 声明的数据成员和成员函数可从类外部的任何地方访问。
而private 数据将被隐藏，在类外不可见，这就实现了数据封装的思想。
要从类外操纵private 成员，只能通过类的public或protected成员来实现。 类成员的访问类成员的访问public (公共变量/公共方法)
容许全权访问，无任何限制(先构造对象，再访问)class A {
public int x;
public void print() { … }
}
class B {
void test() {
A a = new A();
a.x = 100;
a.print();
}
}package abc;
public class A {
public int x;
public void print() { … }
}
package xyz;
import abc.A;
public class B {
void test() {
A a = new A();
a.x = 100;
a.print();
}
}直接访问公有变量x
和公共方法print()类成员的访问类成员的访问private (私有变量/私有方法)
仅能在其所定义的类中被访问(先构造对象，再访问)D:\>javac A.java
x has private access in A
a.x = 100;
^
print() has private access in A
a.print();
^
2 errorsclass A {
private int x;
private void print() { … }
}
class B {
void test() {
A a = new A();
a.x = 100;
a.print();
}
}类成员的访问类成员的访问protected (保护变量/保护方法)
容许类本身、子类(有一定限制)以及同一个包中所有类访问(先构造对象，再访问)class A {
protected int x;
protected void print() { … }
}
class B {
void test() {
A a = new A();
a.x = 100;
a.print();
}
}package abc;
class A {
protected int x;
protected void print() { … }
}
package xyz;
import abc.A;
class B extends A {
void test(A a, B b) {
a.x = 100;
a.print();
b.x = 100;
b.print();
}
}//illegal
//illegal
//legal
//legalbut a subclass in another package can access the protected members in the super-class via only the references of subclass or its subclasses. a subclass in the same package doesn’t have this restriction. this ensures that classes from other packages are accessing only the members that are part of their inheritance hierarchy. 就算在子类中，也只能通过子类（或子类的子类）的引用来访问父类中的protected方法和成员变量。 直接通过父类和另一个子类来访问父类中的protected方法和成员变量就不行。 类成员的访问类成员的访问无修饰 (友好变量/友好方法)
容许类本身以及同一个包中所有类访问class A {
int x;
void print() { … }
}
class B {
void test() {
A a = new A();
a.x = 100;
a.print();
}
}package abc;
class A {
int x;
void print() { … }
}
package abc;
class B {
void test() {
A a = new A();
a.x = 100;
a.print();
}
}类成员变量的访问类成员变量的访问小结* 指子类与父类不在同一个包中的情况类的继承性 类的继承性 创建子类
class <子类名> extends <父类名> {
//子类体
}
继承的传递性
类的继承性类的继承性类成员访问修饰符与继承的关系
私有的(private)类成员不能被子类继承
公共的(public)和保护性的(protected)类成员能被子类继承，且子类和父类可以属于不同的包
无修饰的父类成员，仅在本包中才能被子类继承
类的继承性类的继承性数据成员
1 数据成员的继承
2 数据成员的隐藏
成员方法
1 成员方法的继承
2 成员方法的覆盖
构造方法
每个子类构造方法的第一条语句，都是隐含地调用super()
类的继承性类的继承性class Point {
int x = 2;
}
class TPoint extends Point {
double x = 4.7;
void printBoth() {
System.out.println(x + " " + super.x);
}
public static void main(String[] args) {
TPoint t = new TPoint();
t.printBoth();
System.out.println(t.x + " " + ((Point)t).x);
}
}4.7 2
4.7 2 this和super引用 this和super引用 关键词 this
this指当前对象
应用1: 加强程序可读性(this可有可无)
应用2: 在一个构造函数中调用另一个构造函数
关键词 super
super指直接父类对象
super用来解决如何直接访问或初始化从父类继承来的属性。
super有两种通用形式：调用父类的构造函数、用来访问被子类的成员覆盖的父类成员。
它用在对象的构造函数中，将构造细节通过继承链往上传递。
super()必须是在子类构造函数中的第一个执行语句。
this和super引用this和super引用class Flower {
String name;
int price;
Flower () {
this("tulip", 10);
}
Flower (String s, int i) {
name = s;
price = i;
} void print () {
System.out.println(name
+ " " + price);
}
public static void main(String
args[]){
Flower f = new Flower();
f.print();
}
}nullThisExample.javapublic class ThisExample {
private String name;
private int age;
ThisExample (String name,int age){
this.setName(name); //用this引用当前对象
this.setAge(age);
this.print();
}
public static void main(String[] args){
ThisExample dt=new ThisExample ("Kevin",22);
}程序运行结果：
Name=Kevin ge=22 public void setName(String name){
this.name=name;//this指明赋值号左边为成员变量
}
public void setAge(int age){
this.age=age;
}
public void print(){
System.out.println("Name="+name+" ge="+age);
}
}
nullSuperExample.javaclass Person{
public int c;
private String name;
private int age;
protected void setName(String name){
this.name=name;
}
protected void setAge(int age){
this.age=age;
}
protected void print(){
System.out.println("Name="+name+" Age="+age);
}
} public class SuperExample extends Person{
public void print(){
System.out.println("test:");
super.print(); //直接调用父类的成员方法
}
public static void main(String[] args){
SuperExample ds=new SuperExample ();
ds.setName("kevin");
ds.setAge(22);
ds.print(); //调用覆盖后的方法
}
}程序运行结果：
test:
Name=kevin Age=22nullMoreExamples.javaclass Person{
public static void prt(String s){
System.out.println(s);
}
Person(){
prt("A Person.");
}
Person(String name){
prt("A person name is:"+name);
}
}
public class MoreExamples extends Person{
MoreExamples (){
super(); //1 调用父类构造函数
prt("A chinese.");//2 直接使用从父类继承过来的方法
} null MoreExamples (String name){
super(name);//3 调用父类具有相同形参的构造函数
prt("his name is:"+name);
}
MoreExamples (String name,int age){
this(name);//4 调用当前具有相同形参的构造函数
prt("his age is:"+age);
}
public static void main(String[] args){
MoreExamples cn=new MoreExamples ();
cn=new MoreExamples ("kevin");
cn=new MoreExamples ("kevin",22);
}
}MoreExamples.java程序运行结果：
A Person.
A chinese.
A person name is:kevin
his name is:kevin
A person name is:kevin
his name is:kevin
his age is:22类的多态性 类的多态性
【示例】Overrride.java
class A{
public int getVal(){
return(5);
}
}
class B extends A{
public int getVal(){
return(10);
}
}
public class Overrride {
public static void main(String[] args) {
B b = new B();
int x= b.getVal();
System.out.println(x);
}
}程序运行结果：
10nullpublic class OverloadExamples {
//重载的方法
int add(int a,int b){return(a+b);}
// int add(long a,long b){} 非法重载，long和int是同一简单类型的参数
//重载的方法
double add(double a,double b){return(a+b);}
//重载的方法
double add(double a,double b,double c){ return(a+b+c);}
public static void main(String args[]){
int a;
double b,c;
OverloadExamples p=new OverloadExamples ();
a=p.add(1, 2); //因为a为int型，所以调用的是重载方法
b=p.add(1, 2); //因为b为double型，所以调用的是重载方法
c=p.add(1, 2, 3); //调用重载方法
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
}
}程序运行结果：
a=3
b=3.0
c=6.0重载nullclass A{
public void GetVal(){
System.out.println("Parent");
}
}
class B extends A{
public void GetVal(){
System.out.println("Child");
}
}
public class OverrrideExample {
public static void main(String[] args) {
B b = new B();
A a= (A)b;//把 b 强 制转换成A的类型; 上面两句等价于 A a = new B();
a.GetVal();
}
}程序运行结果：
Child覆盖nullTest.java
//定义超类superA
class superA{
int i = 100;
void fun(){
System.out.println(“This is superA”);
}
}
//定义superA的子类subB
class subB extends superA{
int m = 1;
void fun(){
System.out.println(“This is subB”);
}
}//定义superA的子类subC
class subC extends superA{
int n = 1;
void fun(){
System.out.println(“This is subC”);
}
}nullclass Test{
public static void main(String[] args){
superA a;
subB b = new subB();
subC c = new subC();
a=b;
a.fun(); //(1)
a=c;
a.fun(); //(2)
}
} Test.java程序运行结果：
This is subB
This is subC类的多态性类的多态性覆盖方法的注意事项
（1）父类被覆盖的方法的声明必须要和子类的同名方法的声明完全匹配，覆盖的方法的返回值必须和被覆盖的方法的返回一致。
（2）被覆盖的方法不能为private
（3）覆盖后的方法不能比被覆盖的方法有更严格的访问权限（可以相同）。
（4）覆盖后的方法不能比被覆盖的方法产生更多的例外，即抛出更多的异常。类的多态性类的多态性 class A{
void f() throws IOException{
// 方法体
}
}
class B extends A{
private void f() throws Exception类的多态性类的多态性方法重载的注意事项：
(1）Java的方法重载要求同名的方法必须有不同的参数表，参数类型不能是同一简单类型的参数，如int与long。
(2）方法的修饰符可以不相同。
（3）一个类的多个构造函数之间还可以相互调用，通过关键字this来实现。这个调用语名必须是整个构造函数的第一个可执行语句。类的多态性类的多态性覆盖与重载的区别：
（1）方法的覆盖是子类和父类之间的关系，而重载是同一类内部多个方法间的关系；
（2）方法的覆盖一般是两个方法间的，而重载时可能有多个重载方法；
（3）覆盖的方法有相同的方法名和形参表，而重载的方法只能有相同的方法名，不能有相同的形参表；
（4）覆盖时区分方法的是根据调用他的对象，而重载是根据形参来决定调用的是哪个方法；构造方法构造方法创建对象/实例化对象—new
例1: Apple a = new Apple(); (创建对象)
例2: Apple a; (对象的说明)
a = new Apple(); (实例化对象)
对象的实例化通过构造方法(constructor)来实现
构造方法的名字与类名相同
构造方法没有返回值
构造方法可以有多个，构成方法的重载(overload)nullExample.javaclass Car{
//数据成员
public String Name;
public char Color;
protected int Style;
//成员方法
public String getName(){
return Name;
}
public char getColor(){
return Color;
}
public int getStyle(){
return Style;
}
}nullpublic class Example {
public static void main(String args[]) {
//创建car类的两个对象car1和car2
Car car1=new Car("car1",'R',1);
Car car2=new Car("car2",'B',2);
//对象的成员方法的调用
System.out.println("Color of car1:"+ car1.getColor());
System.out.println("Style of car2:"+car2.getStyle());
}
}构造方法重载构造方法重载输出结果:
20
20 50
10 20构造方法构造方法默认构造方法
例 class Apple {
int color;
}
Apple a = new Apple();
对象实例的判断: null
例 Apple a;
if (a == null)
System.out.println(“no one”);
运行时系统自动赋予
一个空构造函数
如 Apple() { }构造方法构造方法再谈构造方法 class Cmethod {
Cmethod (boolean b) { }
public static void main (String args[]) {
Cmethod c1 = new Cmethod();
Cmethod c2 = new Cmethod(false);
}
} class Cmethod {
Cmethod (boolean b) { }
public static void main (String args[]) {
//Cmethod c1 = new Cmethod();
Cmethod c2 = new Cmethod(false);
}
} class Cmethod {
Cmethod (boolean b) { }
Cmethod () {}
public static void main (String args[]) {
Cmethod c1 = new Cmethod();
Cmethod c2 = new Cmethod(false);
}
}运行时系统自动赋予一个空构造方法，
仅仅当该类没定义构造方法的情况下构造方法和方法构造方法和方法 构造方法和方法在下面三个区别：修饰符，返回值，命名。
构造方法不能有以下非访问性质的修饰： abstract, final, native, static, 或者 synchronized。
构造方法没有返回值，也不需要void。
构造方法使用和类相同的名字。
静态修饰符、静态数据成员和静态成员方法 静态修饰符、静态数据成员和静态成员方法 static (静态数据成员/静态方法)
类的变量/方法，独立于类的对象，可以直接根据类名调用
class S {
static int A = 12, B = 34;
static void print() { … }
}
class Test {
public static void main(String args[]) {
System.out.println(“A=“ + S.A + “ B=“ + S.B);
S.print();
}
}
null class Test {
public void print(int x) {
System.out.println(x);
}
public static void main(String args[]) {
int x = 3;
print(x);
}
}class Test {
public void print(int x) {
System.out.println(x);
}
public static void main(String args[]) {
int x = 3;
Test t = new Test();
t.print(x);
}
}class Test {
public static void print(int x) {
System.out.println(x);
}
public static void main(String args[]) {
int x = 3;
print(x);
}
}nullclass T{
static int X;
int Y;
static void setX(int i){X=i;}
void setY(int i){Y=i;}
static int getX(){return X;}
int getY(){return Y;}
}练习：阅读并写出结果。public class Test {
public static void main(String args[]){
T t1=new T();
T t2=new T();
t1.setX(1);
t2.setX(2);
t1.setY(10);
t2.setY(20);
System.out.println(t1.getX());
System.out.println(t2.getX());
System.out.println(t1.getY());
System.out.println(t2.getY());
}
} null
public class Employee
{
private String name;
private int id;
//静态数据成员nextId属于Employee类，而不属于类的某个对象。
private static int TId = 1;
public Employee(String s){
name = s;
id = 0;
setId();
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getId()
{
return id;
}
public void setId()
{
id = TId;
TId++;
}
public static int getNextId()
{
return nextId; //return static field
}
public static void main(String[] args){
Employee e1 = new Employee ("Harry");
System.out.println(e1.getName() "\t" + e1.id );
Employee e2 = new Employee ("Tom");
System.out.println(e2.getName() + "\t" + e2.id );
Employee e3 = new Employee ("Kidd");
System.out.println(e3.getName() + "\t" + e3.id );
}
}程序运行结果：
Harry 1
Tom 2
Kidd 3 定义一个雇员类，
属性有姓名，工号。方法有获取、设置属性的方法。
要求雇员工号统一从“1”开始，不得缺漏。nullclass Constants {
final int FIRST = 1;
final static int SECOND = 2;
public static void main(String[] args){
int iteration = SECOND;
if (iteration == FIRST)
System.out.println("first iteration");
else
if (iteration == SECOND)
System.out.println("second iteration");
}
}抽象类(abstract class)抽象类(abstract class)一个未完成的类
抽象类可以包含抽象方法(abstract methods)
抽象方法: 仅仅申明了方法，但未实现
有访问修饰词
返回值类型
方法名
参数列表
无方法体
抽象类 1抽象类 1定义抽象类的目的是提供可由其子类共享的一般形式。
子类可以根据自身需要扩展抽象类。
抽象类不能实例化。
抽象方法没有函数体。
抽象方法必须在子类中给出具体实现。abstract 修饰符可与类和方法一起使用抽象类2抽象类2在以下情况下，某个类将成为抽象类：
当一个类的一个或多个方法为抽象方法时。
当该类为一个抽象类的子类，并且没有为所有抽象方法提供实现细节或方法主体时。
当一个类实现一个接口，并且没有为所有抽象方法提供实现细节或方法主体时。抽象类(abstract class)抽象类(abstract class)abstract class Point {
int x = 1, y = 1;
void move(int dx, int dy) {
x += dx;
y += dy;
alert();
}
abstract void alert();
}class SimplePoint extends Point {
void alert() { }
}抽象方法: 有访问修饰词、
返回值类型、方法名和
参数列表，无方法体抽象类(abstract class)抽象类(abstract class)抽象类不能被实例化，例Point p = new Point();
子类继承抽象类时，必须重写抽象方法，否则仍为抽象类abstract class Point {
int x = 1, y = 1;
void move(int dx, int dy) {
x += dx;
y += dy;
alert();
}
abstract void alert();
}abstract class ColoredPoint extends Point {
int color;
}class SimplePoint extends Point {
void alert() { }
}nullAbstractTest.javaabstract class PrintMechine{ //定义抽象类PrintMechine
abstract public void print(int x); //定义抽象方法print()，无方法体
}
public class AbstractTest extends PrintMechine{
int a;
public AbstractTest (int a){
this.a=a;
}
public void print(int a){//实现父类的抽象方法
System.out.println(a*2);
}
public static void main(String[] args){
PrintMechine p1=new AbstractTest (3); //运行时多态
p1.print(3);
}
} 程序运行结果：
6最终类、最终变量和最终方法最终类、最终变量和最终方法final类: 不能有子类
final变量: 定义一个常数，即变量值不能改变
final double AVOGADRO = 6.022e23;
final方法: 方法不能被覆盖
class ChessAlgorithm {
. . .
final void nextMove(ChessPiece pieceMoved,
BoardLocation newLocation) {
...
}
. . .
}
接口接口一个接口允许一个类从几个接口继承而来。
Java 程序一次只能继承一个类但可以实现几个接口。
接口不能有任何具体的方法。
接口也可用来定义可由类使用的一组常量。
接口提供“is a”关系。 创建接口的步骤2-1创建接口的步骤2-1// 有方法的接口
public interface myinterface {
public void add(int x, int y);
public void volume(int x,int y, int z);
}
// 定义程序使用的常量的接口
public interface myconstants {
public static final double price = 1450.00;
public static final int counter = 5;
} 定义一个接口：创建接口的步骤2-2创建接口的步骤2-2编译如下：
javac myinterface.java
用关键字 implements 实现接口，例如：
class demo implements myinterface
如果有一个以上接口被实现，则用逗号隔开接口名称，如下所示：
class demo implements Mycalc, Mycount接口使用示例接口使用示例interface A {
double g=9.8;
void show( );
}class InterfaceTest {
public static void main(String args[ ]){
B b=new B( );
b.show( );
}
}class B implements A {
public void show( ) {
System.out.println(“g=“+g);
}
}高级访问控制高级访问控制访问修饰符为：
public
protected
private
如果一个类或类的成员前没有任何访问修饰符时，它们获得缺省的访问权限。public 访问修饰符public 访问修饰符只有在使用 public 访问修饰符时，类的成员才可被同一包或不同包中的所有类访问。
也就是说，public 访问修饰符可以使类的特性公用于任何类。 缺省访问权限/protected 访问修饰符缺省访问权限/protected 访问修饰符缺省的成员可以被同一包中的其他类访问。
protected 访问修饰符允许类本身、同一包中的所有类和不同包中的子类访问 。
如果希望一个成员在当前包外可见，但仅仅是成员所在类的子类直接可见，就要使用 protected 修饰该成员。 private 访问修饰符private 访问修饰符private 访问修饰符是限制性最大的一种访问修饰符。
被声明为private的成员只能被此类中的其他成员访问，不能被类外看到。
继承体系结构中最高级别的类决不会被声明为 private 类。 高级访问控制
总结
初级经济法重点总结下载党员个人总结TXt高中句型全总结.doc高中句型全总结.doc理论力学知识点总结pdf
高级访问控制总结封装类封装类基本数据类型不是对象层次结构的组成部分。有时需要象处理对象一样处理这些基本数据类型，可通过相应的“封装类”来将其“封装”。 封装类使用示例封装类使用示例Boolean wrapBool = new Boolean("false");
Integer num1 = new Integer ("31");
Integer num2 = new Integer("3");
int sum = num1.intValue() * num2.intValue();intValue()
返回调用对
象的整型值 class CmdArg {
public static void main(String args[]){
int sum = 0;
for(int cnt = 0; cnt < args.length; cnt++)
sum+=Integer.parseInt(args[cnt]);
System.out.println("和为："+sum);
}
} parseInt()方法将执行
从字符串转换成与之相
应的整型（int）值 内部类内部类内部类为非静态的嵌套类。
在类中定义的类称为内部类。
内部类之外的类称为外部类。
内部类可以访问其外部类的所有变量和方法，并能够以和外部类的其他非静态成员相同的方式直接引用它们。
内部类完全在其包围类的范围之内。总结 2-1总结 2-1类中的静态变量、方法或代码块并不具体到实例，它们可以与类的名称一起使用，而无需创建类的对象来访问类的静态特性。
final 修饰符可应用于类、方法和变量。
定义抽象类的目的是提供可由其子类共享的一般形式。
接口就是需要由其他类实现的行为模板。 总结 2-2总结 2-2访问修饰符为：
public
protected
privat
浙公网安备 33021202002483