您的位置:js12345金沙官网登入 > 网络编程 > JAVAjs12345金沙官网登入-面向对象编程基础

JAVAjs12345金沙官网登入-面向对象编程基础

2019-10-02 10:00

this关键字JAVA语言中,this关键字被用来代替本类对象的引用。

7、内部类

如果类中再定义一个类,那么类中再定义的那个类被称为内部类,比如汽车和发动机的关系。内部类可以分为成员内部类、局部内部类和匿名类。

Basic_oop_static.printWater();

2、类的继承

继承的基本思想就是基于某个父类的扩展,制定出一个新的子类,子类集成父类原有的属性和方法,也可以增加原来父类所不具备的属性和方法,或者直接重写父类的某些方法。例如平行四边形是特殊的四边形,可以说平行四边形继承了四边形类,这是平行四边形类将四边形类的所有属性和方法都保留了下来,并基于四边形类扩展了一些新的属性和方法。
接下来,我们介绍继承的四个小的知识点

extends关键字
在java中,让一个类继承另一个类,用extends实现

方法的重写
重写就是在子类中将父类的成员方法的名称保留,重新编写成员方法的实现内容,更改成员方法的存储权限或者修改成员方法的返回值类型。
值得注意的一点是,修改方法的修饰权限时,只能从小变大,比如父类的权限是protected,那么子类的权限只能是public。

super关键字
如果子类重写了父类的方法,如果想调用父类的方法,可以使用super关键字。
同样,在构造函数中,使用super关键字可以调用父类的构造方法,而子类构造方法中的其他代码只能写在super之后。
在类的继承机制中,当实例化子类对象时,父类对象也相应被实例化,也就是说,会自动调用父类的无参构造方法,但是有参构造方法不能被调用,只能依赖于super关键字。

下面,我们基于一个例子来体会下上面所介绍的内容:

public class Pads extends Computer{
    String sayHello(){
        return super.sayHello() + "平板电脑";
    }

    public static void main(String[] args){
        Computer pc = new Computer();
        System.out.println(pc.sayHello());
        Pads pad = new Pads();
        System.out.println(pad.sayHello());
    }
}

class Computer{
    String sayHello(){
        return "欢迎使用";
    }
}

输出为:

欢迎使用
欢迎使用平板电脑

object类
在java中,所有类都直接或者间接继承了java.lang.Object类,它是所有类的父类,在Object类中,有几个比较重要的方法:
getClass().getName() : 该方法可以得到类的名称。
toString():toString()方法的功能是将一个对象返回为字符串形式。
equals():在object类中,equals方法实现的是==的功能,即比较两个对象的引用地址,所以如果想让equals方法比较的是对象的内容的话,需要对该方法进行重写。

public class StaticTest { static String name; static{ System.out.println(name + "静态代码块"); } { System.out.println(name + "非静态代码块"); } public StaticTest{ name = a; System.out.println(name + "构造方法"); } public void method(){ System.out.println(name + "成员方法"); } public static void main(String[] args){ StaticTest s1; StaticTest s2 = new StaticTest; StaticTest s3 = new StaticTest; s3.method(); }}

4、抽象类和接口

水池的水量0水池注水两次水池的水量6水池放水两次水池的水量2

7.2 局部内部类

内部类不仅可以在类中进行定义,也可以在类的局部位置定义,如在类的方法或任意的作用域中均可以定义内部类。

interface OutInterface2{

}

public class OuterClass3 {
    public OutInterface2 doit(final String x){
        class InnerClass2 implements OutInterface2{
            InnerClass2(String s){
                s = x;
                System.out.println(s);
            }
        }
        return new InnerClass2("doit");
    }
}

我们直接用一个简单的例子来介绍一下类的一些基本元素

4.1 抽象类

通常说四边形具有4条边,或者更具体一点,平行四边形是具有对边平行且相等的特性的特殊的四边形,等腰三角形是其中两条边相等的三角形,但对于一般的图形对象,我们很难使用具体的语言去描述,它有几条边,究竟是什么图形,没有人能说清楚,这种类在java中被定义为抽象类。

使用abstract关键字定义的类称为抽象类,而使用abstract关键字定义的方法称为抽象方法。

在使用抽象类和抽象方法时,必须遵循下面的原则:
1)抽象类中,可以包含或者不包含抽象方法,但是包含抽象方法的类必须是抽象类。
2)抽象类不能直接被实例化
3)抽象类被继承后,子类需要实现其中所有的抽象方法
4)如果继承抽象类的子类也被声明为抽象类,则可以不用实现父类中所有的抽象方法。

下面是一个抽象类的代码:

public class goShopping {
    public static void main(String[] args){
        Market market = new WallMarket();
        market.name = "沃尔玛";
        market.goods = "七匹狼西服";
        market.shop();
        market = new TaoBaoMarket();
        market.name = "淘宝";
        market.goods = "韩都衣舍花裙";
        market.shop();
    }
}

abstract class Market{
    public String name;
    public String goods;
    public abstract void shop();
}


class TaoBaoMarket extends Market{
    @Override
    public void shop() {
        System.out.println(name +  "网购" + goods);
    }
}

class WallMarket extends Market{
    @Override
    public void shop() {
        System.out.println(name + "实体店购买" + goods);
    }
}

输出为:

沃尔玛实体店购买七匹狼西服
淘宝网购韩都衣舍花裙

类是同一类事物的统称,如果将现实世界中的一个事物抽象成对象,类就是这类对象的统称,比如鸟类,家禽类等等。具有相同特征和行为的一类事物就称为类。类与对象的关系可以如下来描述:类是世间事物的抽象称呼,而对象则是这个事物相对应的实体。

6、final关键字

定义为final的类不能被继承
final的方法不能被重写
用final声明的变量不能被改变,也就是说final声明的变量可以认为是常量。但这个常量是相对于一个对象来说的,要想使一个变量变为真正的常量,也就是对所有对象来说,其值都是一样的,应该定义为static final,如下面的例子中,两个对象的a1值是不一样的,但是a2是一样的。

import java.util.Random;
import static java.lang.System.out;

public class FinalStaticData {
    private static Random rand = new Random();
    private final int a1 = rand.nextInt(10);
    private static final int a2 = rand.nextInt(10);

    public static void main(String[] args){
        FinalStaticData fdata = new FinalStaticData();
        out.println("a1_value" + fdata.a1);
        out.println("a2_value" + fdata.a2);

        FinalStaticData fdata1 = new FinalStaticData();
        out.println("a1_value" + fdata1.a1);
        out.println("a2_value" + fdata1.a2);
    }
}

输出为:

a1_value3
a2_value6
a1_value0
a2_value6

封装封装是面向对象编程的核心思想,将对象的属性和行为封装起来,其载体就是类,类通常对客户隐藏其实现细节,这就是封装的思想。类为用户提供对象的属性和行为的接口,用户通过这些接口使用这些类,无须知道这些类内部是如何构成的,不能操作类中的内部数据。

4.3 抽象类和接口的区别

1)子类只能继承一个抽象类,但可以继承多个接口。
2)一个类要实现一个接口必须要实现接口中的所有方法,但是抽象类只用实现抽象方法。
3)抽象类中的成员变量可以是各种类型,但是接口中的成员变量只能是public static final
4)接口中只能定义抽象方法,但是抽象类中可以定义非抽象方法
5)抽象类中可以有静态方法和静态代码块,接口中不可以
6)接口不能被实例化,没有构造方法,但抽象类可以有构造方法

public class Basic_oop { public int x = 100; public int y = 100; public int getX(){ return this.x; } public void setX { this.x = x; } public int getY() { return y; } public void setY { this.y = y; } public int getSum(int x,int y){ return x + y; } public void change{ for(int i=0;i<x.length;i++) { x[i] = 100 * i; } } public int getSum{ int sum = 0; for(int i=0;i<x.length;i++){ sum += x[i]; } return sum; } public Basic_oop(){ } public Basic_oop(int x,int y){ this.x = x; this.y = y; } public static void main(String[] args){ Basic_oop obj = new Basic_oop; System.out.println; System.out.println; int[] arr = new int[]{0,1,2}; obj.change; for(int i:arr){ System.out.print; } }}

5、访问控制

java中的访问控制符主要有public、protected、default、private,那么这四种访问控制符的访问权限如下表所示:

public protected default private
本类 可见 可见 可见 可见
本类所在包 可见 可见 可见 不可见
其他包中的子类 可见 可见 不可见 不可见
其他包中的非子类 可见 不可见 不可见 不可见

继承类与类之间同样具有关系,继承是关联中的一种。举例来说,四边形中有平行四边形,梯形等等,平行四边形具有四边形的所有性质,比如有四条边,内角和为360度等等,但是,平行四边形也有普通四边形所不具备的特殊性质,比如两组对边平行等等。 在JAVA中,我们将类似于平行四边形的类称为子类,将类似于四边形的类称为父类或者超类。

7.1 成员内部类

在成员内部类中,内部类可以随意使用外部类的成员方法以及成员变量,但是内部类的成员只有在内部类的范围之内的可知的,不能被外部类使用。内部类的对象实例化操作必须在外部类或外部类的非静态方法中实现。

public class OuterClass {
    innerClass in = new innerClass();
    public void ouf(){
        in.inf();
    }

    class innerClass{
        innerClass(){

        }
        public void inf(){

        }
        int y = 0;
    }

    public innerClass doit(){
        in.y = 4;
        return new innerClass();
    }

    public static void main(String[] args){
        OuterClass out = new OuterClass();
        OuterClass.innerClass in = out.doit();
        OuterClass.innerClass in2 = out.new innerClass();
    }
}

如果在外部类中定义的成员变量与内部类的成员变量名称相同,可以使用this关键字。下面的例子中,x是形参,this.x代表内部类的x,TheSameName.this.x++代表了外部类的成员变量x:

public class TheSameName {
    private int x = 5;
    private class Inner{
        private int x = 9;
        public void doit(int x){
            System.out.println(x) ;
            System.out.println(this.x);
            System.out.println(TheSameName.this.x++);
        }
    }
    public static void main(String[] args){
        TheSameName tsn = new TheSameName();
        TheSameName.Inner inner = tsn.new Inner();
        inner.doit(2);
    }
}

输出为:

2
9
5
 public Basic_oop(int x,int y){ this.x = x; this.y = y; }

3、类的多态

多态意为一个名字可具有多种语义,类的多态性可以从两个方面来体现:一是方法的重载,二是类的上下转型。

方法的重载:方法的重载就是在一个类中允许同时存在一个或者多个以上的同名方法,只要这些方法的参数个数或类型不同即可。方法的重载与方法的重写的区别要注意区分,重写指的是子类继承父类时,重新实现父类中的非私有方法。
如下面的代码,我们定义了多个add方法,由于add方法的参数类型、参数个数、参数顺序不同,都构成了方法的重载。

public class OverLoadTest {
    public static int add(int a) {
        return a;
    }

    public static int add(int a, int b) {
        return a + b;
    }

    public static int add(int a, double b) {
        return (int) (a + b);
    }

    public static double add(double a, double b) {
        return a + b;
    }

    public static int add(double a, int b) {
        return (int) (a + b);
    }

    public static int add(int... a) {
        int s = 0;
        for (int i : a) {
            s += i;
        }
        return s;
    }
}

向上转型
向上转型指把子类对象直接赋值给父类类型的变量,如定义一个四边形类Quadrangle和一个平行四边形类Parallelogram:

Quadrangle q = new Parallelogram()

与向上转型相对应的是向下转型,即把一个父类对象直接赋值给子类类型的变量,这往往是不可以的,正如平行四边形都是四边形,但不是四边形都是平行四边形一样,这样做是有危险的,我们需要显式强制转换才可以。

isinstanceof关键字
可以使用isinstanceof操作符来一个类是否是某个类的实例。

由于声明就会调用静态代码块,而String的默认值为null,所以首先输出 null静态代码块,由于每次调用new来构造对象,都会首先调用非静态代码块,然后执行构造方法,所以接连输出:null非静态代码块、s2构造方法、s2非静态代码块、s3构造方法。由于成员方法只有在对象调用时才会执行,所以最后输出:s3成员方法。

7.4 静态内部类

在内部类堑添加修饰符static,这个内部类就变为静态内部类了,一个静态内部类中可以声明静态成员,但是在非静态内部类中不可以声明静态成员。静态内部类中不能使用外部类的非静态成员,所以静态内部类在程序开发中比较少见。

成员变量成员变量即对象的属性,可以看到,我们建立了一个Basic_oop的类,类的对象有两个属性,或者说是两个成员变量,分别是x和y。

4.2 接口声明及实现

接口是抽象类的延伸,可以将它看作是纯粹的抽象类,接口中所有方法都没有方法体,接口使用interface关键字进行定义。而接口继承接口时,使用extends关键字,而类继承接口时,使用的是implements关键字。这里要注意区分。当子类实现接口时,必须实现接口中所有的方法。另外一点需要注意的是,接口中所有的变量都是static和final的,所以必须进行初始化,而实现接口的子类不能对接口中的变量进行重新赋值。
下面是一个接口的举例:

public class QuadrangleUseInterface {
    public static void main(String[] args){
        drawTest[] d = {new SquareUseInterface(),new ParallelogramgleUseInterface()};
        for(int i=0;i<d.length;i++){
            d[i].draw();
        }
    }
}


interface drawTest{
    public void draw();
}

class ParallelogramgleUseInterface implements drawTest{
    @Override
    public void draw() {
        System.out.println("平行四边形.draw()");
    }
}

class SquareUseInterface implements drawTest{
    @Override
    public void draw() {
        System.out.println("正方形.draw()");
    }
}

输出为:

正方形.draw()
平行四边形.draw()

可以看到,接口同样适用向上转型。

由final static修饰的成员变量即为静态常量,静态常量由类的所有对象所共享,且不能被改变:

7.3 匿名内部类

使用如下的语法创建内部类:

return new A(){
  //内部类体
}

** 对象的创建**对象的创建使用new关键字,如果不传入参数,将调用默认的无参构造函数创建,如果带参数,则使用有参的构造函数创建:

1、类的封装

将对象的属性和行为封装起来的载体就是类,类通常对客户隐藏其实现细节,这就是封装的思想。比如,我们到餐厅去点餐,我们创建一个餐厅的对象,同时创建一个厨师的对象,用户可以进行点餐,然后就可以吃饭,但没办法知道厨师的具体信息,以及厨师如何做这道菜的。代码实现如下:

public class Resturant {
    Cook cook = new Cook();
    public void takeOrder(String dish){
        cook.cooking(dish);
        System.out.println("您的"+dish+"做好了,请慢用");
    }

    public String saySorry(){
        return "抱歉,本餐厅不提供此项服务";
    }

    public static void main(String[] args){
        Resturant res = new Resturant();
        System.out.println("请帮我做一份香辣肉丝");
        res.takeOrder("香辣肉丝");
        System.out.println("你们的厨师叫什么名字");
        System.out.println(res.saySorry());
    }
}



class Cook {
    private String name;
    public Cook(){
        this.name = "Tom Cruise";
    }
    private void cutUnion(){
        System.out.println(this.name + "切葱花");
    }
    private void washVegetables(){
        System.out.println(this.name + "洗蔬菜");
    }
    void cooking(String dish){
        this.washVegetables();
        this.cutUnion();
        System.out.println(this.name + "开始烹饪" + dish);
    }
}

输出为:

请帮我做一份香辣肉丝
Tom Cruise洗蔬菜
Tom Cruise切葱花
Tom Cruise开始烹饪香辣肉丝
您的香辣肉丝做好了,请慢用
你们的厨师叫什么名字
抱歉,本餐厅不提供此项服务

1、对象引用超过其作用范围;2、将对象赋值为null。

 final static int inPerTime = 3; final static int outPerTime = 2;
Basic_oop obj = new Basic_oop;

成员方法成员方法即类对象的行为,我们定义了获得属性值和设置属性值的set和get方法。同时,为了介绍成员方法的参数的概念,我们定义了两个getSum方法和一个change方法。那么在成员方法中传递参数,有三种方式。值参数值参数表明实参与形参之间按值传递,因此对形参的修改不会引起实参的变化引用参数如果在给方法传递参数时,参数的类型是数组或者其他引用类型,那么在方法中对参数的修改会反映到原有的数组或者其他引用类型上,这种类型的方法参数,称为引用参数。如上面的例子中,change方法修改了原来数组中的三个值,变成了0、100和200,那么打印将输出0、100和200。不定长参数声明方法时,如果有若干个相同类型的参数,可以定义为不定长参数,在参数类型和参数名之间有三个点即可。比如上例中的第二个getSum方法。

本文由js12345金沙官网登入发布于网络编程,转载请注明出处:JAVAjs12345金沙官网登入-面向对象编程基础

关键词:

  • 上一篇:没有了
  • 下一篇:没有了