第十天笔记

时间：2015-04-14 09:45:41 阅读：118 评论：0 收藏：0 [点我收藏+]

标签：

黑马程序员第十天笔记

<a href="http://www.itheima.com" target="blank">java培训</a>

1.接口定义

关键字 interface 接口名{

成员变量：

Public static final int I=10；

成员方法：

Public abstract 返回值类型方法名（参数）；

}

接口的权限必须最大public，不写权限，编译的时候，自动加上

/*
  接口实例 
*/

interface Demo  //定义接口
{
    public static final int I=10; 
    public abstract void method(); 
}
class DemoTest  implements Demo
{
   public  void method()//重写类的方法
    {
       System.out.println("这是接口的单例"); 
    }
}
class InterfaceDemo 
{
    public static void main(String[] args) 
    {
         DemoTest d= new DemoTest();
         d.method();
         System.out.println(d.I);
    }
}

2.接口的使用

接口不能建立对象，不能new

由于接口中的方法全抽象，子类必须全部重写。叫做实现。关键字是implements。

定义类实现接口，重写接口中全部的抽象方法，建立实现类对象

Class XXX implements 接口类{

全部重写方法

}

如果实现类，重写了抽象类的部分方法，还是抽象类。

多态:父类或者接口引用，指向子类对象

/*
 猫狗案例,加入跳高的额外功能
*/
//定义动物的抽象类
abstract class Animal
{
    Animal(){}
    Animal(String name,int age){
    this.name=name;
    this.age=age;
    }
    private String name;
    private int age;
    public void setName(String name){this.name=name;}
    public void setAge(int age){this.age=age;}
    public String getName(){return name;}
    public int getAge(){return age;}
     
    public abstract void eat();
}
//定义猫类
class Cat extends Animal
{
    Cat(){}
    Cat(String name,int age){super(name,age);}
    public  void eat()
    {
        System.out.println("猫在吃猫粮");
    }
    public void catchMouse()
    {
      System.out.println("猫在捉老鼠");
    }

}
//定义狗类
class Dog  extends Animal
{
    Dog(){}
    Dog(String name,int age){super(name,age);}
      public  void eat()
    {
        System.out.println("狗在啃骨头");
    }
    public void lookHome()
    {
      System.out.println("狗在看家");
    }
}
//定义算数接口
interface Computer
{
   public abstract void computer();
}
//定义跳高接口
interface Jump
{
    public abstract void jump();
}
//定义会算数的狗
class ComDog extends Dog implements Computer
{
   ComDog(){}
   ComDog(String name,int age){super(name,age);}
     public  void computer()
    { 
      System.out.println("会做算数的小狗");
       }
}
//定义会跳高的猫
class JmpCat extends Cat implements Jump
{
    JmpCat(){}
    JmpCat(String name,int age){super(name,age);}
    public  void jump()
        {
        System.out.println("会跳高的小猫");
         }
}
class  InterfaceDemo1
{
    public static void main(String[] args) 
    {
        //一般的小狗
        Dog d=new Dog("白白",5);
        d.eat();
        d.lookHome();
        System.out.println(d.getName()+"今年"+d.getAge()+"岁啦");
        System.out.println("............................");
        //一般的小猫
        Cat c=new Cat();
        c.setName("豆豆");
        c.setAge(9);
        c.eat();
        c.catchMouse();
        System.out.println(c.getName()+"今年"+c.getAge()+"岁啦");
        System.out.println("............................");

        //调用会算算数的小狗
         ComDog cd=new ComDog("小花",7);
         cd.eat();
         cd.lookHome();
         cd.computer();
         System.out.println(c.getName()+"今年"+c.getAge()+"岁啦");
         System.out.println("............................");


         //调用会跳高的小猫
          JmpCat jc=new JmpCat();
          jc.setName("大豆");
          jc.setAge(20);
          jc.eat();
          jc.catchMouse();
          jc.jump();
          System.out.println(jc.getName()+"今年"+jc.getAge()+"岁啦");
          System.out.println("............................");
    }
}

3.类与类，类与接口，接口和接口之间的接口

类和类之间，继承关系，单继承，只能继承一个类，但是可以多层继承

类和接口：实现关系，一个类实现接口，重写抽象方法。一个类可以实现多个接口，每个接口之间用逗号隔开。

接口和接口之间：是一个继承关系，而且接口之间支持多继承。一个接口可以同时继承多个接口。

4抽象类和接口的区别

A．成员区别：

抽象类：非抽象方法，抽象方法，变量，常量，构造方法

接口：常量，抽象方法

B．使用区别

抽象类：子类继承，重写抽象方法。普通方法，子类可以直接使用

接口：常量，抽象方法

C.关系区别

抽象类，继承关系，单继承

接口类，实现关系，多实现

接口之间，多继承

D．设计理念不同

抽象类，继承体系最共性内容 is...a关系

接口，继承体系中的扩展内容，like...a关系

5.接口的特点
A.接口是一个对外暴露的规则，规定内容，并没有具体实现

B.接口降低程序的耦合性（紧密连接），提高扩展性

C．面向接口编程

/*
教练和运动员案例
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。

*/
//定义抽象人
abstract class Person
{
    Person(){}
    Person(String name,int age){this.name=name;this.age=age;}
    private String name;
    private int age;
    public void setName(String name){this.name=name;}
    public void setAge(int age){this.age=age;}
    public String getName(){return name;}
    public int getAge(){return age;}
    public abstract void eat();
    public abstract void sleep();

}
//定义说英语接口
interface SpeakEnglish
{
    public abstract void speakEnglish();
}
//定义运动员
abstract class player extends Person
{
    player(){}
    player(String name,int age){super(name,age);}
    public abstract void play();

}
//定义教练
abstract class Coach extends Person
{
    Coach(){}
    Coach(String name,int age){super(name,age);}
    public abstract void coach();
}
//定义篮球运动员
abstract class BaskPlayer extends player
{
    BaskPlayer(){}
    BaskPlayer(String name,int age){super(name,age);}
    public abstract void baskplay();

}
//定义说英语的篮球运动员
class BaskPlayerSpeak extends BaskPlayer implements  SpeakEnglish
{
    BaskPlayerSpeak(){}
    BaskPlayerSpeak(String name,int age){super(name,age);}
    public  void eat()
    {
     System.out.println("篮球运动员在吃饭");
    }
    public  void sleep()
    {
     System.out.println("篮球运动员在睡觉");
    }
    public  void play()
    {
     System.out.println("篮球运动员在打球");
    }
     public  void baskplay()
    {
         System.out.println("篮球运动员在打篮球");
     }
     public  void speakEnglish()
    {
         System.out.println("会说英语的篮球运动员");
     }
}
//定义篮球教练
abstract class BaskCoach extends  Coach
{
    BaskCoach(){}
    BaskCoach(String name,int age){super(name,age);}
    public abstract void baskcoach();

}
//定义说英语的篮球教练
class BaskCoachSpeak extends BaskCoach implements  SpeakEnglish
{
    BaskCoachSpeak(){}
    BaskCoachSpeak(String name,int age){super(name,age);}
    public  void eat()
    {
     System.out.println("篮球教练在吃饭");
    }
    public  void sleep()
    {
     System.out.println("篮球教练在睡觉");
    }
    public  void coach()
    {
     System.out.println("篮球教练在指挥打球打球");
    }
     public  void baskcoach()
    {
         System.out.println("篮球教练在指挥打篮球");
     }
     public  void speakEnglish()
    {
         System.out.println("会说英语的篮球教练");
     }
}
//定义乒乓球运动员
class PinpPlayer  extends player 
{
    PinpPlayer(){}
    PinpPlayer(String name,int age){super(name,age);}
    public  void eat()
    {
     System.out.println("乒乓球运动员在吃饭");
    }
    public  void sleep()
    {
     System.out.println("乒乓球运动员在睡觉");
    }
    public  void play()
    {
     System.out.println("乒乓球运动员在打球");
    }
    public  void pingPlay()
    {
     System.out.println("乒乓球运动员在打乒乓球");
    }

}
//定义乒乓球教练
class PinpCoach extends Coach
{
    PinpCoach(){}
    PinpCoach(String name,int age){super(name,age);}
    public  void eat()
    {
     System.out.println("乒乓球教练在吃饭");
    }
    public  void sleep()
    {
     System.out.println("乒乓球教练在睡觉");
    }
    public  void coach()
    {
     System.out.println("乒乓球教练在指挥打球");
    }

    public  void pinpCoach()
    {
     System.out.println("乒乓球教练在指挥打乒乓球");
    }
}


class  InterfaceDemo3 
{
    public static void main(String[] args) 
    {
         //普通乒乓球运动员
         PinpPlayer  pp=new PinpPlayer("王明",20);
         pp.eat();
         pp.sleep();
         pp.play();
         pp.pingPlay();
         System.out.println(pp.getName()+"......"+pp.getAge());
         System.out.println("................................");


         //普通乒乓球教练
         PinpCoach pc=new PinpCoach();
         pc.setName("陈锋");
         pc.setAge(39);
         pc.eat();
         pc.sleep();
         pc.coach();
         pc.pinpCoach();
         System.out.println(pc.getName()+"......"+pc.getAge());
         System.out.println("................................");


         //说英语的篮球运动员
         BaskPlayerSpeak bps=new BaskPlayerSpeak("姚明",20);
         bps.eat();
         bps.sleep();
         bps.play();
         bps.baskplay();
         bps.speakEnglish();
         System.out.println(bps.getName()+"......"+bps.getAge());
         System.out.println("................................");

         //说英语的篮球教练
         BaskCoachSpeak bcs=new BaskCoachSpeak("杨力",40);
         bcs.eat();
         bcs.sleep();
         bcs.coach();
         bcs.baskcoach();
         bcs.speakEnglish();
         System.out.println( bcs.getName()+"......"+ bcs.getAge());
         System.out.println("................................");

    }
}

6.形式参数和返回值问题案例

A．形式参数

基本类型

引用类型

B. 返回值类型

基本类型

引用类型

C.链式编程

/*
  方法返回值类型，是抽象类，或者是接口
*/
//定义接口，返回值是接口
interface Face
{
  public abstract void a();
}
class FaceDemo1 implements Face
{
    public void a()
    {
      System.out.println("这是接口的子类");
    }
}
class FaceDemo2
{
   public Face method()
    {
        return new FaceDemo1();
   } 
}
//定义抽象类 ，返回值是抽象类
abstract class AbstractDemo1
{
    public abstract void method();
}
class  AbstractDemo2 extends  AbstractDemo1
{
    public  void method()
    {
       System.out.println("这是的抽象类的子类");
    }
}
class  AbstractDemo3
{
    public AbstractDemo1 method2()
    {
        return new AbstractDemo2();
    }
}
class ArgumentsDemo2 
{
    public static void main(String[] args) 
    {
        //返回值是接口
        Face f=new FaceDemo2().method();
        f.a();

        AbstractDemo1 a=new AbstractDemo3().method2();
        a.method();
            

    } 
}

7.包的概述

包在操作系统中，对应的就是文件夹

对类，进行分类管理

全类名：包名.类名

8.定义包

关键字 package 包名；

包名：字母全部小写，如果是多级包，使用。隔开

Package定义包，要求爱整个文件的第一行

包是不能重复定义的。只能写一次

9．带包编译和运行

手动模式，直接编译java文件

按照包的名字，创建文件夹，编译后的class文件，复制进去

手动模式，太复杂

自动模式：编译Java文件

编译完成后，文件夹就创建完成了，class文件，自动被复制进去

javac命令的参数 -d 实现 -d指定编译后的目录

格式： javac -d 存储目录 XXX.java

编译后的class文件，和源文件java文件，分开 c:\myclass

set classpath 为JVM指明运行的class文件在哪里

10.包与包之间类的访问

第四种权限，受保护

JAVA中非常特殊权限protected

被受保护修饰的内容，只给子类用

子类中创建父类对象，调用受保护的方法，是报错的

在子类中，只能super调用，不能建立对象调用

Public protected 默认 private

同一类 OK OK OK Ok

同一包(子类) OK OK OK NO

外包子类 OK OK NO NO

不同包 OK NO NO NO

11.导入包

是一种简化形式，避免繁琐的包名书写

Import 包名.类名；

Import语句必须写在package的下面，可以写多个

如果包中的类有多个类，直接用*代替，必须写到类的当前包才有意义。

12．内部类概述

在一个类的内部，定义一个类

class A{

class B{}

}

B叫做A的内部类，A叫做B的外部类

B类可以直接使用A的成员，包括私有

A类要是使用B类的成员，建立B类的对象

按照定位不同

成员内部类：直接写在外部类的成员位置

局部内部类: 写在了外部类的一个方法里面

13.成员内部类的使用

外部类，成员位置定义内部类

使用内部类中的方法

格式1 ：内部类是非静态的，内部类的方法是非静态的

外部类.内部类变量 = new 外部类对象().new内部类对象();

变量.内部类方法();

格式2：内部类静态，内部类方法静态

外部类.内部类.内部类方法();

格式3：内部类是静态的，内部类方法非静态

外部类.内部类变量 = new 外部类.内部类对象();

14.局部内部类，访问局部变量，加final

生命周期：对象生存时间大于方法的局部生命时间

加final后，可以访问，但是变量的生命定义的区间有关，和是不是final没有关系

15.匿名内部类

还是编写格式

匿名内部类的前提，必须有继承类，或者实现接口

匿名内部类，是一种简化形式，简化了实现类的操作

标准格式：

New 接口或者父类（）{

重写抽象方法

}；

第十天笔记

标签：

原文地址：http://www.cnblogs.com/liman/p/4423954.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行