20189200余超 2018-2019-2 移动平台应用开发实践第二周作业

2018-2019-2 移动平台应用开发实践第二周作业

实验部分，在linux中用git命令将代码传到码云上

• 成功上传的截图
  

• 码云上的截图
  

• 遇到如下的问题
  

• 解决方法
  我发现在进行第一步git clone命令时候，没有用到我码云的https地址，并且在此地址的基础上cd一个后面部分的文件夹；比如我的码云https的地址为https://gitee.com/yuchao20189220/over_20189220java.git，所以如下图所示
  

• 遇到问题
  运行一下"statistics.sh"脚本的时候，发现：
  

• 解决方法
  

• "statistics.sh"脚本运行结果图
  

看书部分

• 首先，对象的创建：类名 对象名=new 类名();也许大多数学习java的都会写，但是理解方面是这样的，new一个类名，就会得到一个对象，而这个对象的类型就是这个类名的类型比如说：Car car=new Car();就是通过new一个Car类名，得到car这个对象，而这个对象就是Car类型的。
• 类必须先定义才能使用。类是创建对象的模板，创建对象也叫类的实例化。package com.cnblogs;//定义包的格式，关键词package包的名字最规范的格式是域名的反写，比如com.什么

public class People {//class关键字，定义类的关键字，People是类的名称
    
    public String name;//类的属性
    public String sex;
    public int age;   

　//类的方法　
    public void sleep(){
        System.out.println("人疲倦的时候喜欢睡觉觉");
    }
    
    public void eat(){
        System.out.println("人饥饿的时候喜欢吃饭饭");
    }
    public static void main(String[] args) {//主函数
        People p=new People();//对象的实例化
        p.eat();//调用类的方法
        p.sleep();
    }

}

• 3：构造方法,构造方法的名称必须与类的名称相同，并且没有返回值。每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认的构造方法。

public class People {
    
    public String name;
    public String sex;
    public int age;
    
    public People(){//默认的构造方法，初始化对象的时候调用默认构造方法
        System.out.println("类默认的构造方法,不含参数");
    }
    public People(String name){//含参的构造方法
        System.out.println("含参的构造方法");
    }
    public void sleep(){
        System.out.println("人疲倦的时候喜欢睡觉觉");
    }
    
    public void eat(){
        System.out.println("人饥饿的时候喜欢吃饭饭");
    }
    public static void main(String[] args) {
        People p=new People();
        p.eat();
        p.sleep();
    }
    
}

• Java 通过修饰符来控制类、属性和方法的访问权限和其他功能，通常放在语句的最前端。权限(访问)修饰符关键字包含：public ,private ,protected，另外一个就是默认的;public:对所有类可见，包含本类，同包其他类或者子类，其他包的类或者子类。protected:对本类可见，对同包其他类或者子类可见，对其他包的类或者子类不可以见。private:只对本类可见，对同包其他类或者子类不可见，对其他包的类或者子类不可以见。默认：则是对同一包内可见。实例如下：

package com.cnblogs;

public class Men {
    
    public String name;//共有属性
    private int age;//私有属性
    protected String sex;//受保护的属性
    int a=10;//默认的
}

• 变量的作用域，包含全部变量和局部变量举例如下:

package com.cnblogs;

public class Men {
    //全部变量，在整个作用域都可以使用
    public String name;//共有属性
    private int age;//私有属性
    protected String sex;//受保护的属性
    int a=10;
    public static void main(String[] args) {
        //定义的i是局部变量，只可以在for循环这个局部内进行使用
        for(int i=0;i<10;i++){
            System.out.println("局部变量，在可以在局部进行使用"+i);
        }
    }
    
}

• this 关键字用来表示当前对象本身，或当前类的一个实例，通过 this 可以调用本对象的所有方法和属性。成员变量与方法内部的变量重名时，希望在方法内部调用成员变量，怎么办呢？这时候只能使用this。作为方法名来初始化对象，也就是相当于调用本类的其它构造方法，它必须作为构造方法的第一句。作为参数传递，需要在某些完全分离的类中调用一个方法，并将当前对象的一个引用作为参数传递时。

package com.cnblogs;

public class Dog {
    
    int a=21;
    int b=12;
    
    public Dog(){//this关键字作为方法名来初始化对象
        this(23,43);
    }
    
    public Dog(int a, int b) {
        // TODO Auto-generated constructor stub
        this.a=a;
        this.b=b;
        System.out.println(a+" "+b);
    }

    public void add(){//通过this关键字可以调用类的属性和方法
        int c=this.a+this.b;
        System.out.println(c);
    }
    
    public void setA(int a){//使用this关键字区分同名变量
        this.a=a;
    }
    public int getA(){
        return a;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Dog d=new Dog();
        d.add();
        
        d.setA(44);
        int dd=d.getA();
        System.out.println(dd);
    }

}

• JAVA中方法的重载（构造方法也可以重载）即方法的名字相同，而方法的参数类型，个数，顺序不同即为方法的重载注意1：声明为final的方法不可以重载，声明为static的方法不能被重载，但是能够被再次声明。注意2：仅仅是返回值类型不同，不能构成方法的重载

package com.cnblogs;

public class Cat {
    
    public void cat(){
        System.out.println("方法的重载");
    }
    public void cat(int a,int b){
        System.out.println("方法的重载，方法中参数的个数");
    }
    public void cat(String c,int d){
        System.out.println("方法的重载，方法中参数的类型不同");
    }
    public void  cat(int e,String f){
        System.out.println("方法的重载，方法中参数顺序不同");
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
    }

}

• 包装类（Wrapper Classes），拆箱和装箱.基本类型和对应的包装类可以相互装换：由基本类型向对应的包装类转换称为装箱，例如把double包装成 Double 类的对象；包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象重新简化为 int。

package com.cnblogs;

public class Sun {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a=32;
        Integer i=new Integer(a);
        System.out.println("手动进行装箱"+i);
        
        int a2=i.intValue();//此方法的作用是以int值返回此Integer对象
        System.out.println("手动进行拆箱"+a2);

　　　int a4=54;
        Integer i4=a4;//自动装箱
        System.out.println("自动进行装箱"+i4);
    }

}

接口和抽象类

对于面向对象编程来说，抽象是它的一大特征之一。在Java中，可以通过两种形式来体现OOP的抽象：接口和抽象类。

• 在了解抽象类之前，先来了解一下抽象方法。抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法的声明格式为：

abstract void fun();

• 抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。从这里可以看出，抽象类就是为了继承而存在的，如果你定义了一个抽象类，却不去继承它，那么等于白白创建了这个抽象类，因为你不能用它来做任何事情。对于一个父类，如果它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需求来进行不同的实现，那么就可以将这个方法声明为abstract方法，此时这个类也就成为abstract类了。
  包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。注意，抽象类和普通类的主要有三点区别：
• 1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。
• 2）抽象类不能用来创建对象；
• 3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。在其他方面，抽象类和普通的类并没有区别。
• 接口，英文称作interface，在软件工程中，接口泛指供别人调用的方法或者函数。从这里，我们可以体会到Java语言设计者的初衷，它是对行为的抽象。在Java中，定一个接口的形式如下：

[public] interface InterfaceName {`
}

• 接口中可以含有 变量和方法。但是要注意，接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其他关键字，比如private、protected、static、 final等会报编译错误），并且接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。从这里可以隐约看出接口和抽象类的区别，接口是一种极度抽象的类型，它比抽象类更加“抽象”，并且一般情况下不在接口中定义变量。

• 抽象类和接口的区别
  1.语法层面上的区别

　　1）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；

　　2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；

　　3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；

　　4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。

2.设计层面上的区别

　　1）抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。

　　2）设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过ppt里面的模板，如果用模板A设计了ppt B和ppt C，ppt B和ppt C公共的部分就是模板A了，如果它们的公共部分需要改动，则只需要改动模板A就可以了，不需要重新对ppt B和ppt C进行改动。而辐射式设计，比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。

多态

• 定义，多态指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）。

• 实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

• 现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

• 多态存在的三个必要条件一、要有继承；二、要有重写；三、父类引用指向子类对象。

• Java中多态的分类：
  在java中，多态大致可以分为以下几种情况：

1)person为父类，student为子类。那么：person p=new student()；

2)fliable为接口，bird为实现接口的类，那么：fliable f=new bird()；

3)fliable为抽象类，bird为继承fliable的类，那么：fliablef=new bird()；

多态时需要说明p声明为父类的引用，但他实际为子类引用。但是他只能调用父类中的方法。如果子类中的方法覆盖了父类方法，那么将调用父类方法（虚方法调用）。接口多态也是同样的，也许你会问，如果f要调用自己的方法，那岂不是出错了？其实这里也是方法的覆盖，因为实现接口的子类肯定会实现接口中的方法， 所以此种情况下调用的是bird中的方法。但是如果bird有一个方法在接口中没有定义，那么f不能调用。