面向对象编程基础
类和对象
类：就是对现实生活中事物的描述。
对象：就是这类事物实实在在的存在的个体。new();
&&属性对应的是类中变量，行为对应的是类中的函数（方 法）。其实在定义类时就是在描述事物，就是在定义属性和行为。属性和行为共同为类中的成员。
3.1.1面向对象
1、匿名对象。
如：实名对象是 car c=new car();
C.num=4;
C.color=”red”;
匿名对象是new car();
可以简写上面的代码为：new car().num=4;
New car().color=”red”;
具体程序如下：
package km.com.fxw;
class CarDemo {
public static void main(String[] args) {
/*
Car c=new Car();//实名对象
c.num=4;
c.color="red";
c.run();
/*
new car();//匿名对象
//简化程序代码
new car().num=4;
new car().color="red";
new car().run();
*/
}
}
匿名对象使用方式一：当对对象的方法只条用一次时，可以用匿名对象来完成。如果对一个对象进行多个成员调用，必须给给定对象起名。
匿名对象的使用方式二：可以将匿名对象作为实际参数进行传递。
3.2.5 访问权限
Public：设置没有限制的访问权限，其他类的方法都能访 问。
Private:设置最强的访问权限，其他的类都不能访问。
Protected:只限于子类或者同一包中的类的方法能访问。
<default>:（无修饰，有好的）只允许同一包中类的方法 访问。
3.2.6 继承
：在java语言中，继承是通过扩展原有的类，声明新类来实现，扩展声明的新类称为子类，原有的类称为超类，简称（父类）。
***：在java语言中不支持多重继承，限定一个类只有一个超类。在子类声明中加入extends子句来指定超类。
格式例如：
Class 子类名 extends 超类名
{
类体
}
例如代码：
Class E extends D
{
}
/*
声明类E的超类是D,这里假定类D已经在某处声明，类声明时，缺少extends子句，未指定超类，则该类的超类是系统声明的类java.lang.Obiect.
*/
一、多态性。
package km.cn;
class Shape
{
float area()//抽象的几何形状，返回值一律为0.
{ return 0.0f;}
}
class Circle extends Shape//声明extends子句
{
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_11 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Circle c;Rectangle r;
c=new Circle(1.0f);
r=new Rectangle(3.0f,4.0f);
System.out.println("圆面积="+returnArea(c));
System.out.println("长方形面积="+returnArea(r));
}
static float returnArea(Shape s)
{
return s.area();
}
}
二、多层继承。
：继承声明的新类，又可被其他类再继承，从而构成多层继承。
package km.cn;
class day1 {
public void start()
{System.out.println("starting...");}
}
class Aircraft extends day1{
public void fly()
{System.out.println("fly...");}
}
class lesson extends Aircraft
{
public void whirl()
{System.out.println("whirling...");}
}
class work extends Aircraft
{
public void zoom()
{System.out.println("zooming...");}
}
//上述事例就是属于多层继承
三、多层继承中的方法调用顺序。
package km.cn;
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 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
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");
}
}
四、final类、final方法、final变量。
：意思就是不能变的意思。在声明类之前用final修饰，声明类是final类，final类是不能被继承的类，即它不能再有子类。
Final class A{
..........
}
Final修饰方法，意思就是该方法不能被子类的方法覆盖。
Final iny f(int x,int y){
...........
}
用final修饰变量，意思是该变量是不能改变的的值。
Final int f=100;
局部变量在定义的时候可以暂时不设初值，但是已经初始化，以后就不能再改变。
五、abstract类和abstract方法。
Abstract称为抽象类。
抽象类只是声明一种模板，没有具体实现代码的类。只有它的子类才有可能是有实际意义的类。
*抽象类可以没有抽象方法，但是抽象方法一定有抽象类。
package km.cn;
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=1;
}
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.print("我的半径是："+radius);
//x,y为圆心，半径为radius的圆。
}
}
class ShapeDraw
{
void draw(Shape obj)
{
obj.Draw();//利用动态联编，按实际对象调用相应的Draw()方法。
}
}
public class Page3_14 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ShapeDraw sd=new ShapeDraw();
Square s=new Square(10,10,10);
Circle c=new Circle(30,30,5);
sd.draw(s);//以s为实参调用sd的draw方法。
sd.draw(c);//以c为实参调用sd的draw方法。
}
}
六、关键字super.
子类隐藏了超类的成员变量或者覆盖了超类方法后，利用关键字super，子类方法可以引用超类的成员变量和被覆盖的方法。
package km.cn;
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 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
C c=new C(2,3.0,'C');
c.method();
}
}
七、关机字this
:关键字this用来指对象自己，this作用有多种；例如：将对象自己作为参数，调用别的方法；当方法的局部变量隐藏成员变量时，利用this调用成员变量，在构造函数内调用另一构造函数等。
ClassB
{
Int b,c;
B(){this(2,3);}//构造函数内调用另一构造函数
B（int x,int y）{b=x;c=y;}
}
八、is-a和has-a关系
：类A继承扩展类B，则子类A和超类B之间的关系就是is-a.
程序如下：
package km.cn;
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 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
A obj=new A(1,2);
}
}
|
|
收藏
淘帖
踩
