java包 + 接口的定义与实现接口抽象方法 + 并发视频

原则上一个软件对应一个进程。
多进程：在操作系统中能(同时)运行多个任务(程序)  例如：Android你没启动一个”软件“开启一个进程
多线程：在同一个应用程序中。。。。

-------------------------------------------------------------

线程进入就绪状态，还不能直接运行， 还要抢CPU， 谁抢到who运行
程序要运行必须经过CPU--一个CPU同时只能执行一条指令

上面单线程程序
下面多线程程序

------------------------------------------------------------------------

1. //如果抽象类的类体里的方法全部都是抽象方法,可以把这个类定义为接口  
2. //换言之,类体里全部都是抽象方法,可以把这个类定义为接口.  
3. interface Runer//接口的定义,接口里只包含常量和抽象方法.  
4. {  
5.     String texing="动时要振动";//接口里的常量默认是用public static final标志的  
6.     void run();//默认的访问权限是public.  
7.     String jump();  
8. }  
9.   
10. interface Animals extends Runer//一个新的接口可以继承另一个接口  
11. {  
12.     void breathe();//在继承的基础上,有新的矿展.动物不仅能动,还能呼吸.  
13. }  
14. //实现接口抽象方法的方式 注意联想实现抽象类里的抽象方法的方式.  
15. abstract class Fish  implements Animals//实现接口抽象方法的定义  
16. {//如果省掉abstract, Fish类类体必须覆盖Animals里的所有抽象方法,否则报错.  
17.     public void run()//public不能省,因为上面都是public型,子类访问父类,访问权限不能比父类低  
18.     {  
19.     System.out.println("Fish is swiming");  
20.     }  
21.     public String jump()  
22.     {  
23.         System.out.println("Fish靠尾巴跳动");  
24.         return "wooo";  
25.     }  
26.     public void breathe()  
27.     {  
28.     System.out.println("Fish呼出的是汽泡");  
29.     }  
30. }  
31. //比较:实现抽象类的抽象方法与实现接口的抽象方法所采取的方式.  
32. //实现抽象类的抽象方法,是通过abstract class 子类名 extends 父类名     -----格式  
33. //实现接口的抽象方法,是通过abstract class 类名a  implements 类名b       ------格式  
34. //两者相同点:都要声明抽象类abstract class 类名,不同点,前者用关键字extends  
35. //后者用implements  

简洁代码:

[java] view plaincopyprint?

1. interface Runer  
2. {  
3.     String texing="动时要振动";  
4.     void run();  
5.     String jump();  
6. }  
7.   
8. interface Flyer  
9. {     
10.     int ID=20;  
11.     void fly();  
12. }  
13.   
14. interface Animals extends Runer  
15. {  
16.     void breathe();  
17. }  
18.   
19. abstract class Bird implements Runer,Flyer//实现多个接口  
20. {  
21.     public void run() {}  
22. }  
23. abstract class Fish  implements Animals//实现接口  
24. {  
25.     public void run()  
26.     {  
27.     System.out.println("Fish is swiming");  
28.     }  
29.     public String jump()  
30.     {  
31.         System.out.println("Fish靠尾巴跳动");  
32.         return "wooo";  
33.     }  
34.     public void breathe()  
35.     {  
36.     System.out.println("Fish呼出的是汽泡");  
37.     }  
38. }  
39. //class person {}  
40. abstract class student extends person implements Runer,Flyer//继承一个类的同时,实现多个接口.  
41. {  
42.     public void run() {}  
43.     public String jump(){return "ee";}  
44. }  

--------------------------------------------------------------------------------------------------------------

1.包的概念

包（package）是Java提供的一种区别类的名字空间的机制，是类的组织方式，是一组相关类和接口的集合，它提供了访问权限和命名的管理机制。

Java中提供的包主要有以下3种用途:

  1) 将功能相近的类放在同一个包中，可以方便查找与使用。

  2) 由于在不同包中可以存在同名类，所以使用包在一定程度上可以避免命名冲突。

  3) 在Java中，某次访问权限是以包为单位的。

1.1创建包

创建包可以通过在类或接口的源文件中使用 package语句实现，package语句的语法格式如下：

package 包名;

包名：必选，用于指定包的名称，包的名称为合法的 Java标识符。当包中还有包时，可以使用“包1.包2.…….包n”进行指定，其中，包1为最外层的包，而包n则为最内层的包。

package 语句通常位于类或接口源文件的第一行。例如，定义一个类Circ，将其放入com.wgh包中的代码如下：

package com.wgh;

public class Circ {

final float PI=3.14159f;       //定义一个用于表示圆周率的常量PI

// 定义一个绘图的方法

public void draw(){

System.out.println("画一个圆形！");

}

}

说明：

在Java中提供的包，相当于系统中的文件夹。例如，上面代码中的Circ类如果保存到C盘根目录下，那么它的实际路径应该为C:\com \wgh\Circ.java。

2 使用包中的类

类可以访问其所在包中的所有类，还可以使用其他包中的所有public类。访问其他包中的public类可以有以下两种方法。

1) 使用长名引用包中的类

使用长名引用包中的类比较简单，只需要在每个类名前面加上完整的包名即可。例如，创建Circ类（保存在com.wgh包中）的对象并实例化该对象的代码如下：

com.wgh.Circ circ=new com.wgh.Circ();

2) 使用import语句引入包中的类

由于采用使用长名引用包中的类的方法比较繁琐，所以Java提供了import语句来引入包中的类。import语句的基本语法格式如下：

import 包名1[.包名2.……].类名|*;

当存在多个包名时，各个包名之间使用“.”分隔，同时包名与类名之间也使用“.”分隔。

*：表示包中所有的类。

例如，引入com.wgh包中的Circ类的代码如下：

import com.wgh.Circ;

如果 com.wgh包中包含多个类，也可以使用以下语句引入该包下的全部类。

import com.wgh.*;

JAVA的extends用法

   理解继承是理解面向对象程序设计的关键。在Java中，通过关键字extends继承一个已有的类，被继承的类称为父类(超类，基类)，新的类称为子类(派生类)。在Java中不允许多继承。
（1）继承

[java] view plaincopy

1. class Animal{  
2.     void eat(){  
3.         System.out.println("Animal eat");  
4.     }  
5.     void sleep(){  
6.         System.out.println("Animal sleep");  
7.     }  
8.     void breathe(){  
9.         System.out.println("Animal breathe");  
10.     }  
11. }  
12.   
13. class Fish extends Animal{  
14. }  
15.   
16. public class TestNew {  
17.     public static void main(String[] args) {  
18.         // TODO Auto-generated method stub  
19.         Animal an = new Animal();  
20.         Fish fn = new Fish();  
21.           
22.         an.breathe();  
23.         fn.breathe();  
24.     }  
25. }  

在eclipse执行得：
Animal breathe! 
Animal breathe! 
.java文件中的每个类都会在文件夹bin下生成一个对应的.class文件。执行结果说明派生类继承了父类的所有方法。

（2）覆盖

[java] view plaincopy

1. class Animal{  
2.     void eat(){  
3.         System.out.println("Animal eat");  
4.     }  
5.     void sleep(){  
6.         System.out.println("Animal sleep");  
7.     }  
8.     void breathe(){  
9.         System.out.println("Animal breathe");  
10.     }  
11. }  
12.   
13. class Fish extends Animal{  
14.     void breathe(){  
15.         System.out.println("Fish breathe");  
16.     }  
17. }  
18.   
19. public class TestNew {  
20.     public static void main(String[] args) {  
21.         // TODO Auto-generated method stub  
22.         Animal an = new Animal();  
23.         Fish fn = new Fish();  
24.           
25.         an.breathe();  
26.         fn.breathe();  
27.     }  
28. }  

执行结果：

Animal breathe
Fish breathe

在子类中定义一个与父类同名，返回类型，参数类型均相同的一个方法，称为方法的覆盖。方法的覆盖发生在子类与父类之间。另外，可用super提供对父类的访问。

 

java中的继承

java中的继承（子类调用父类构造方法还不懂） 

declarations  n. 声明
extends  v. 继承

继承中注意的问题：
1  重写(也叫覆盖，也叫重构)：重写方法必须和被重写方法具有相同的方法名称、参数列表和返回值类型；
            重写方法不能使用比被重写方法更严格的访问权限。
重写是类与类之间的关系，两者必须是继承关系。重载是方法与方法之间的关系。

2  关键字super：
    在Java类中使用super来引用父类的成分
    super可用于访问父类中定义的属性
    super可用于调用父类中定义的成员方法
    super可用于在子类构造方法中调用父类的构造方法
    super的追溯不仅于直接父类，就是father的father。。。。。。
Supper关键字有两个特殊的用途：
    在子类构造函数中调用父类的构造函数
    在子类中调用父类的方法。

3  多态：多态就是重写和重载！而上塑造型或虚方法的调用更好的体现了多态。
             上溯造型(也叫虚方法)中，方法是调用子类自己的，属性是调用父类的。(一个引用类型变量如果声明为父类的类型，
             但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法)
public class Father {    
    public String name = "王惠";
    public void bidBoy(){
        System.out.println("今天我要是不打你，我就不是你娘！！！");    
    }
}

public class Son1 extends Father{
    public String name1 = "王鹏的姐姐";
    public String name = "张三三";
    public void bidBoy(){   //重写
        System.out.println("我做错了什么？为什么你要打我！！！");
        System.out.println(super.name);
        System.out.println(name);//如果子类没有name,那么这个name就输出父类的。
    }
}

public class Test{
    public static void main(String args[]){
        Father f = new Son1(); //上溯造型，虚方法调用
        f.bidBoy();//这里调用的是子类中重写父类的方法！上溯造型中，方法是调用子类自己的，属性是调用父类的。
        System.out.println(f.name);
    }
}
输出结果：
    我做错了什么？为什么你要打我！！！
    王惠
    张三三
    王惠

同类收集( homogenous collections)

    MyDate[] m = new MyDate[2];
    m[0] = new MyDate(22, 12, 1964);
    m[1] = new MyDate(22, 7, 1964);

  异类收集(heterogeneous collections)

    Person [] p= new Person[3];
    p[0] = new Student();//跟person有继承关系
    p[1] = new Person();
    p[2] = new Graduate();//跟person有继承关系

方法声明的参数类型为父类类型，可以使用子类的对象作为实参调用该方法
public class Test{ 
    public void method(Person e) {
               //……
               e.getInfo();
    }
    public static  void main(String args[]){
               Test t = new Test();
                Student m = new Student();
                t.method(m);
    }
}

4 instanceof 操作符：instanceof操作符的作用是判断一个变量是否是右操作数指出的类的一个对象，
    由于java语言的多态性使得可以用一个子类的实例赋值给一个父类的变量，而在一些情况
    下需要判断变量到底是一个什么类型的对象，这时就可以使用instanceof了。当左操作数是
    右操作数指出的类的实例或者是子类的实例时都返回真，如果是将一个子类的实例赋值给
    一个父类的变量，用instanceof判断该变量是否是子类的一个实例时也将返回真。

5 对象造型 ：
    对Java对象的强制类型转换称为造型
    在造型前可以使用instanceof操作符测试一个对象的类型
    从子类到父类的类型转换可以自动进行
    从父类到子类的类型转换必须通过造型(强制类型转换)实现
    无继承关系的引用类型间的转换是非法的

public class Test{        
       public void method(Person e) {
          System.out.println(e.getschool());   //非法，因为从子类到父类的类型转换可以自动进行，故这里已经是父类了。父类的对象只能调用父类中有的方法。
          if(e intstanceof Student){
                  Student me = (Student)e;
                  System.out.println(me.getschool());
          }        
       }
        public static  void main(Stirng args[]){
               Test t = new Test();
                Student m = new Student();
                t.method(m);
        }
}

综合例子：
public class Animal {
    public String name;
    public void run()
    {
        System.out.println("交通基本靠跑");
    }
    public void say()
    {
        System.out.println("通讯基本靠叫");
  }
}

public class Cat extends Animal{
    /*
     * 如果存在继承关系的话，子类会默认的调用父类的默认构造器，而如果重载父类的构造器，
     * 子类需要调用重载之后的构造器，且父类的构造器必须在子类的最开始最前端进行调用。
     * 
     */
    public Cat()
    {
        super();
    }    
    public void worke()
    {
        System.out.println("猫挠沙发...咔咔...");
    }
    public void say()
    {
        System.out.println("喵喵...");
    }
}

public class Dog extends Animal{
    public void worke()
    {
        System.out.println("狗看门儿！！");
    }
    public void say()
    {
        System.out.println("汪汪汪...");
    }
}

public class AnimalFactory {
    public static void method(Animal[] animal)
    {
        //循环，遍历出Animal数组当中所有的对象并调用Cat/Dog当中的worke/say方法及Animal当中的run/say方法。
        for(Animal a:animal)
        {
            if(a instanceof Dog)
            {
                Dog d = (Dog)a;
                d.worke();
                d.say();
                continue;
            }
            if(a instanceof Cat)
            {
                Cat c = (Cat)a;
                c.worke();
                c.say();
                continue;
            }
            if(a instanceof Animal)
            {
                continue;//这个continue可以省掉
            }
        }
    }
}

public class TestAnimal {
    public static void main(String[] args){    
        Animal[] a = new Animal[3];
        //异类收集
        a[0] = new Dog();
        a[1] = new Cat();
        a[2] = new Animal();
        ((Cat)a[1]).worke();//强制类型转换,因为worke()这个不是子类重写父类的方法，所以必须强制类型转换~
        a[1].say();//这句不需要强制类型转换，因为say()是子类重写父类的方法。
        AnimalFactory.method(a);//method方法是静态的，可以直接调用,当然写上面那条语句也没有错。    
    }
}
输出结果：    
    猫挠沙发...咔咔...
    喵喵...
    狗看门儿！！
    汪汪汪...
    猫挠沙发...咔咔...
    喵喵...

6 方法重载：在同一个类中可以定义多个同名方法。
      重载方法的参数列表必须不同，也就是参数个数或参数类型不同！
      重载方法的返回值类型可以相同，也可以不同
构造方法重载：
    构造方法重载，参数列表必须不同，也就是参数个数或参数类型不同！
    可以在构造方法的第一行使用this关键字调用本类的其它(重载的)构造方法
import java.util.Date;
public class Person {
            private String name;
            private int age;
            private Date birthDate;//Date类型引入util包
            public Person(String name, int age, Date d) {
     this.name = name;
     this.age = age;
     this.birthDate = d;
          }
          public Person(String name, int age) {
     this(name, age, null);
          }
          public Person(String name, Date d) {
     this(name, 30, d);
          }
          public Person(String name) {
     this(name, 30);
          }
}

构造方法不能继承：子类继承父类所有的成员变量和成员方法，但不继承父类的构造方法
调用父类构造方法：子类的构造方法必须调用父类的构造方法！
    如果子类的构造方法中没有显示地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则系统默认调用父类无参数的构造方法
    如果子类构造方法中既未显式调用父类构造方法，而父类中又没有无参的构造方法，则编译出错
    在子类的构造方法中可使用语句super(argument_list) 调用父类的构造方法