链式编程
每次调用方法后，返回的是一个对象
/*
* 链式编程
* 每次调用方法后，返回的是一个对象
*/ class Student {
public void study() {
System.out.println("good good study, day day up!");
}
} class StudentDemo {
public Student getStudent() {
return new Student();
}
} public class InnerClassDemo { public static void main(String[] args) {
// TODO Auto-generated method stub StudentDemo sd = new StudentDemo(); sd.getStudent().study();// 链式编程
}
}
面试题：
要求分别输出30，20，10
注意：
1：内部类和外部类没有继承关系
2：通过外部类名限定this对象
3：Outer.this
/*
面试题：
要求分别输出30，20，10 注意：
1：内部类和外部类没有继承关系
2：通过外部类名限定this对象
3：Outer.this
*/ class Outer {
public int num = 10; class Inner {
public int num = 20; public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
}
}
} public class InnerClassDemo { public static void main(String[] args) {
// TODO Auto-generated method stub Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
匿名内部类在开发中的使用
/*
* 匿名内部类在开发中的使用
*/ interface Person {
public abstract void study();
} class PersonDemo {
// 接口名作为形式参数
// 起始这里需要的不是接口，而是该接口的实现类
public void method(Person p) {
p.study();
}
} class Student implements Person// 实现类
{
public void study() {
System.out.println("good good study, day day up!");
}
} public class InnerClassDemo { public static void main(String[] args) {
// TODO Auto-generated method stub PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method(p); System.out.println("-----------------------------"); pd.method(// 上下作用一样，下面的在Android更常用，因为匿名对象使用以后内存被回收
new Person() {
public void study() {
System.out.println("good good study, day day up!");
}
});
}
}
匿名内部类的面试题
class Outer {
public static Inter method() {
return new Inter() {
public void show() {
System.out.println("hello world.");
}
};
}
}
public class InnerClassDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Outer.method().show();
/*
* 1： Outer.method()可以看出method()应该是Outer的一个静态方法
* 2：Outer.method().show()可以看出method()方法的返回值是一个对象
* 3：接口Inter中有一个show()方法，method()方法的返回值是一个接口
*/
}
}
面试题
/*
* 注意：Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲区获取数据
* */
public class IntegerDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);
Integer i5 = 127;
Integer i6 = 127;
System.out.println(i5 == i6);
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8);
/*
* 通过查看源码，得知针对-128到127之间的数据，做了一个数据缓冲区，如果数据在该范围内的，每次并不创建新的空间 以下是反编译后的语句
* Integer i9 = Integer.valueOf(128);
*/
Integer i9 = Integer.valueOf(128);
Integer i10 = Integer.valueOf(128);
System.out.println(i9 == i10);
}
}
例3.1学生类Student的声明。
class Student {
float heigth, weight;// 成员变量定义
String name, sex, no;// 成员变量定义
void setStudent(String n, String s, String o)// 方法定义
{
name = n;
sex = s;
no = n;
System.out.println("姓名：" + name);
System.out.println("性别：" + sex);
System.out.println("学号：" + no);
}
void setWH(float w, float h)// 方法定义
{
weight = w;
heigth = h;
}
}
例3.2方法的例子，类B有方法u()和v()。
class B {
double x, y;
int u(int x, int y)// 方法u()返回int型值，有两个int型参数
{
return x * x + y * y + 1;// x、y是参数
}
float v(int a, float b) {
return (float) (a * x + b * y);// x、y是成员变量
}
}
例3.3利用关键字this访问被隐藏的成员变量。
class Jerry {
int x, z;
void g(int z) {
int x = 5 + z;// 定义局部变量x，而z是参数
this.x = x;// 局部变量x的值赋值给成员变量x
this.z = z;// 参数z的值赋值给成员变量z
}
}
例3.4方法重载的例子，类C的4个方法或因参数个数不同，或因参数的类型顺序不同，是4个合理的重载方法。
class C {
float fun(float s)// 只有一个float参数
{
return s * s;
}
float fun(float x, int y)// 第一个是float参数，第二个int参数
{
return x * x + y * y;
}
float fun(int x, float y)// 第一个是int参数，第二个float参数
{
return x * x + y * y;
}
float fun(float x, float y, float z)// 有三个是float参数
{
return x * x + y * y + z;
}
}
例3.5类内定义构造方法的例子。类Point定义了两个构造方法。
class Point {
int x, y;
Point()// 无参数的构造方法，点对象被创建时，总是预设x=10，y=20
{
x = 10;
y = 20;
}
Point(int x, int y)// 有两个参数的构造方法，为点对象设置x和y坐标的初值
{
this.x = x;// 成员变量与参数同名，冠this是指成员变量，参见3.2.7
this.y = y;
}
int getX() {
return x;
}
int getY() {
return y;
}
}
例3.6使用对象的程序例子。
public class Example3_1 {
public static void main(String[] args) {
Point p1, p2, p3;// 声明对象p1，p2，p3
p1 = new Point();// 创建对象p1
p2 = new Point(40, 50);// 创建对象p2
p3 = new Point(p1.getX() + p2.getX(), p1.getY() + p2.getY());
System.out.println("P3.x=" + p3.getX() + ",p3.y=" + p3.getY());
Point p4 = new Point(p1.x, p2.y);// 声明并创建对象p4
System.out.println("P4.x=" + p4.x + ",p4.y=" + p4.y);
}
}
例3.7类D定义了一个实例方法，两个类方法。
class D {
int a;// 实例变量
static int c;// 类变量
float max(int x, int y)// 实例方法
{
return a = x > y ? x : y;
}
static void setCount(int c0)// 类方法
{
c = c0;
}
static void incCount(int step)// 类方法
{
c += step;
}
}
例3.8含不合法代码的例子。程序的注释指明合法和不合法的原有。
class E {
float u;
static float v;
static void setUV(boolean f) {
u = s_m(f);// 合法，类方法可以调用类方法
v = r_m(!f);// 非法，类方法不能直接调用实例方法
}
static float s_m(boolean f) {
return f ? u : v;// 非法，类方法只能引用类变量
}
float r_m(boolean f) {
return f ? u : v;// 合法，实例方法能引用实例变量和类变量
}
}
例3.9说明类变量用法的应用程序。改写Point类的声明，在Point类中增加一个类变量pCount，它的初值为0。在构造方法中，有类变量pCount增1的代码，这能记录类的对象个数。
public class Example3_2 {
public static void main(String[] args) {
Point p1, p2, p3;
p1 = new Point();
p2 = new Point(40, 50);
p3 = new Point(p1.getX() + p2.getX(), p1.getY() + p2.getY());
System.out.println("p3.x=" + p3.getX() + ",p3.y=" + p3.getY());
Point p4 = new Point(p1.x, p2.y);
System.out.println("p4.x=" + p4.x + ",p4.y=" + p4.y);
System.out.println("程序共有Point对象" + Point.pointNum() + "个");
}
}
class Point {
int x, y;
static int pCount = 0;
Point()// 无参数的构造方法，点对象被创建时，总是预设x=10，y=20
{
x = 10;
y = 20;
pCount++;
}
Point(int x, int y)// 有两个参数的构造方法，为点对象设置坐标的初值
{
this.x = x;// 由于成员变量与参数同名，this表明是成员变量
this.y = y;
pCount++;
}
static int pointNum() {
return pCount;
}
int getX() {
return x;
}
int getY() {
return y;
}
}
例3.10继承声明子类的例子。
class Mother {
private int money;
float weight, height;
String speak(String s) {
return s;
}
float getWeight() {
return weight;
}
float getHeight() {
return height;
}
String dance() {
return "我会跳舞";
}
}
class Daughter extends Mother {
String cat;
String sing(String s) {
return s;
}
String dance() {
return "我是小舞蹈演员";
}
}
public class Example3_10 {
public static void main(String[] args) {
Daughter girl = new Daughter();
girl.cat = "漂亮的帽子";
girl.weight = 35.0f;
girl.height = 120.0f;
System.out.println(girl.speak("我是女儿"));
System.out.println(girl.speak("我像母亲一样很会说话"));
System.out.println(girl.speak("我重" + girl.weight + "公斤"));
System.out.println(girl.speak("我高" + girl.height + "公分"));
System.out.println(girl.speak("我还比母亲多一项" + girl.cat));
System.out.println(girl.sing("我还能唱歌"));
System.out.println(girl.dance());
}
}
例3.11说明多态性的程序例子。
class Shape {
float area()// 抽象的几何形状，一律返回面积为0
{
return 0.0f;
}
}
class Circle extends Shape {
float R;
Circle(float r) {
R = r;
}
float area()// 圆类重新定义求面积的方法，能正确求出圆的面积
{
return 3.1415926f * R * R;
}
}
class Rectangle extends Shape {
float W, H;
Rectangle(float w, float h) {
W = w;
H = h;
}
float area()// 长方形类也重新定义求面积的方法，能正确求出长方形的面积
{
return W * H;
}
}
public class Example3_4 {
public static void main(String[] args) {
Circle c;
Rectangle r;
c = new Circle(1.0f);
r = new Rectangle(3.0f, 4.0f);
System.out.println("圆面积=" + c.area());
System.out.println("长方形面积=" + r.area());
;
}
}
例3.12一个多层继承的例子。
class Vehicle {
public void start() {
System.out.println(" Starting...");
}
}
class Aircraft extends Vehicle {
public void fly() {
System.out.println(" Flying...");
}
}
class Whirlybird extends Aircraft {
public void whirl() {
System.out.println(" Whirling...");
}
}
class Jet extends Aircraft {
public void zoom() {
System.out.println(" Zooming...");
}
}
例3.13说明多层继承中构造方法调用顺序的例子。
class A {
int a;
A(int a) {
this.a = a;
System.out.println("Constructing A");
}
}
class B extends A {
int b;
B(int a, int b) {
super(a);
this.b = b;
System.out.println("Constructing B");
}
}
class C extends B {
int c;
C(int a, int b, int c) {
super(a, b);
this.c = c;
System.out.println("Constructing C");
}
}
class D extends C {
int d;
D(int a, int b, int c, int d) {
super(a, b, c);
this.d = d;
System.out.println("Constructing D");
}
}
public class Example3_13 {
public static void main(String[] args) {
D obj = new D(1, 2, 3, 4);
System.out.println("对象obj的值是：" + obj.a + "，" + obj.b + "，" + obj.c + "，" + obj.d);
System.out.println("Main Program!");
}
}
例3.14含抽象类和抽象方法的程序。
abstract class Shape// 抽象类
{
int x, y; void MoveTo(int newx, int newy) {
x = newx;
y = newy;
} Shape(int newx, int newy) {
x = newx;
y = newy;
} abstract void Draw();// 抽象方法，没有实现
} class Square extends Shape// 继承抽象类
{
int len;// 正方形边长 Square(int px, int py, int l) {
super(px, py);
len = l;
} void Draw()// 超类抽象方法的具体的实现
{
System.out.print("我是正方形，");
System.out.print("我的中心位置是：" + "(" + x + "," + y + ")，");
System.out.println("我的边长是：" + len);
// 以x，y为中心，边长为len的正方形
}
} class Circle extends Shape// 继承抽象类
{
int radius;// 半径 Circle(int px, int py, int r) {
super(px, py);
radius = r;
} void Draw()// 超类抽象方法的具体的实现
{
System.out.print("我是圆形，");
System.out.print("我的中心位置是：" + "(" + x + "," + y + ")，");
System.out.println("我的半径是：" + radius);
// 以x，y为圆心，半径为radius的圆
}
} class ShapeDraw {
void draw(Shape obj) {
obj.Draw();// 利用动态联编，按实际对象调用相应的Draw()方法
}
} public class Example3_14 {
public static void main(String[] args) {
ShapeDraw sd = new ShapeDraw();
Square s = new Square(10, 10, 20);
Circle c = new Circle(30, 30, 5);
sd.draw(s);// 以s为实参调用sd的draw方法
sd.draw(c);// 以c为实参调用sd的draw方法
}
}
例3.15使用super调用超类构造方法、超类方法和超类成员变量的程序。
class A {
int x;
A(int inf) {
x = inf;
}
void method() {
System.out.println("我是类A的方法！值是" + x);
}
int getX() {
return x;
}
}
class B extends A// 继承类A声明类B
{
double x;
B(int a, double b) {
super(a);// 调用类A的构造方法
x = b;
}
void method() {
System.out.println("我是类B的方法！值是" + x);
}
}
class C extends B {
char x;
C(int a, double b, char c) {
super(a, b);// 调用类B的构造方法
x = c;
}
void method() {
char chCx = x;// 这里的x是类C定义的x
double dBx = super.x;// 引用父类的成员变量，类B的x
int iAx = this.getX();// 不能用A.X，也不能用super.super.x
super.method();// 调用类B的method()方法
System.out.println("我是类C的方法！值是" + x);
System.out.println("我获得的信息是：" + "chCx=" + x + chCx + "，dBx=" + dBx + "，iAx=" + iAx);
}
}
public class Example3_15 {
public static void main(String[] args) {
C c = new C(2, 3.0, 'C');
c.method();
}
}
例3.16类A继承扩展类B，类A和类B之间有is-a关系。
class B {
int b;
B(int x) {
b = x;
}
void write() {
System.out.println("这是来自类B的输出！");
}
}
class A extends B {
int a;
A(int x, int y) {
super(x);
a = y;
write();
System.out.println("我是子类A！" + "b=" + b + "，a=" + a);
}
}
public class Example3_16 {
public static void main(String[] args) {
A obj = new A(1, 2);
}
}
例3.17类A的某个成员变量的类型是B，类A和类B之间是has-a关系。
class A {
B b;
int a;
A(int x, int y, int z) {
b = new B(x, y);
a = z;
b.write();
}
}
class B {
int b1, b2;
B(int x, int y) {
b1 = x;
b2 = y;
}
void write() {
System.out.println("这是来自类B的输出！");
}
}
public class Example3_17 {
public static void main(String[] args) {
A obj = new A(1, 2, 3);
}
}
例3.18一个含内部类的程序。
class A {
B obj;
A() {
obj = new B();
obj.print();
}
class B// B是内部类
{
public void print() {
System.out.println("内部类B...");
}
}
}
public class Example3_18 {
public static void main(String[] args) {
A obj = new A();
}
}
例3.19声明接口和类实现接口的例子。
interface Computable// 声明一个接口
{
final int MAX = 100; void speak(String s); int f(int x); int g(int x, int Y);
} class A implements Computable// 类A实现Computable接口
{
int no; public int f(int x)// 不要忘记public关键字
{
int sum = 0;
for (int i = 1; i <= x; i++) {
sum = sum + i;
}
return sum;
} public int g(int x, int y) {
return x * y;// 至少有return语句
} public void speak(String s) {
// 必须有方法体，但体内可以没有任何语句
}
} class B implements Computable// 类B也实现Computable接口，但实现的方案不同
{
int no; public int f(int x) {
int sum = 0;
for (int i = 1; i <= x; i++) {
sum = sum + i * i;
}
return sum;
} public int g(int x, int y) {
return x + y;
} public void speak(String s) {
// 必须有方法体，但体内可以没有任何语句
}
} public class Example3_19 {
public static void main(String[] args) {
A Li;
B Tom;
Li = new A();
Li.no = 951898;
Tom = new B();
Tom.no = 951899;
System.out.print("Li的编号：" + Li.no + "，最大值：" + Li.MAX);
System.out.print("，从1到100求和=" + Li.f(100));
System.out.println("，3与4的积=" + Li.g(3, 4));
System.out.print("Tom的编号：" + Tom.no + "，最大值：" + Tom.MAX);
System.out.print("，从1平方加到9平方=" + Tom.f(9));
System.out.println("，5与6的和=" + Tom.g(5, 6));
}
}
例3.20说明小应用程序建立和运行步骤的小应用程序。
import java.applet.*;
import java.awt.*; public class Example3_20 extends Applet {
int pos; public void init() {
pos = 5;
} public void start() {
repaint();
} public void stop() { } public void paint(Graphics g) {
g.drawString("我们正在学习Java程序设计", 20, pos + 10);
pos = (pos + 20) % 100 + 5;
}
}