黑马程序员-抽象类借口

<pre name="code" class="java"><2
现在有一种情况，生活情况
package dom;
interface Give{
 public void giveMoney();
}
class RealGive implements Give{
 public void giveMoney(){
  System.out.println("把钱还给我..");
 }
}
class ProxyGive implements Give{
 private Give give =null;
 public ProxyGive(Give give){
  this.give=give;
 }
 public void before(){
  System.out.println("准备：小刀，绳子，钢筋，钢索");
 }
 public void giveMoney(){
  this.before();
  this.give.giveMoney();
  this.after();
 }
 public void after(){
  System.out.println("销毁所有罪证");
 }
}
public class Text {
  public static void main(String[]args){
   Give give =new ProxyGive(new RealGive());
   give.giveMoney();
  }
}
准备：小刀，绳子，钢筋，钢索
把钱还给我..
销毁所有罪证

抽象类和接口在使用上的对比

No	比较点	抽象类	接口
1	组成	抽象方法、普通方法、变量、构造方法、全局常量	抽象方法。全局常量
2	定义	abstract	interface
3	子类	子类通过extends继承一个抽象类	子类通过implements实现接口
4	限制	一个子类只能继承一个抽象类	一个子类可以同时实现多个接口
5	关系	一个抽象类可以实现多个接口	一个接口不能继承一个抽象类，但能继承多个接口
		一个抽象类中允许包含多个接口	一个接口中可以包含多个抽象类

     6                     设计模式                                 模板设计                                                                       工厂设计，代理设计

                                                                                             两个一起可以完成适配器设计

7

实例化

都是通过对象的多态性，通过子类进行对象的实例化操作

8	实现限制	存在单继承限制	不存在此类限制
9	特性		表示一个标准一种能力

优先使用接口

例子：一个抽象类中允许包含一个接口

package dom;

abstract class A{

 public abstract void fun(); //抽象方法

 interface B{                         //接口

  public void print();

 }

};

class X extends A{

 public void fun(){

  System.out.println("**********");

 }

 class Y implements B{  //重点

  public void print(){

   System.out.println("###########");

  }

 }

}

public class Text {

  public static void main(String[]args){

  A a=new X();

  a.fun();

  A.B b=new X().new Y();

  b.print();

  }

}

************

#########

例二

package dom;

interface A{

 public void fun( );//内部抽象类

 abstract class B { //接口

  public abstract void print();

 }

};

class X implements A{

 public void fun(){

  System.out.println("**********");

 }

 class Y extends B{

  public void print(){

   System.out.println("###########");

  }

   }

}

public class Text1 {

  public static void main(String[]args){

  A a=new X();

  a.fun();

  A.B b=new X().new Y();

  b.print();

    }

}

**********

########### 

<1.Object 类

     在java中一切都是继承关系，那么既然一切都是继承关系

class Person{

}

    如果一个雷没有明确的指定继承那个父类，则默认情况下就是继承自Object类

    那么任何对象多可以用Object 接收

package dom;

class Person extends Object{

 

}

public class Text1 {

  public static void main(String[]args){

  Object obj1=new Person();

 Object obj2="你好";

  }

}

//那么，对于Object接受来讲，不光可以接收类的引用，只要是引用数据类型都可以使用Object接收

package dom;

interface National{}

    class Person extends Object implements National{}

public class Text2{

 public static void main(String[]args){

  National na =new Person();//子类为接口实例化

  Object obj =na;//使用Object 接收接口实例

  National temp=(National) obj;

  }

}    

Object接收数组类型

package dom;

public class Text3{

 public static void main(String[]args){

  int i[]={1,2,3,4,5,6,6};

  Object obj=i;

  int x[]=(int[])obj;

  for(int j=0;j<x.length;j++){

   System.out.print(x[j]+",");

  }

 }

} 

1,2,3,4,5,6,6

    Object的功能不只如此，对于一个完整的类来讲，应该覆写Object类中的以下方法

    .toString();对象打印时调用

    .equals();对象比较是调用

    .hashCode();暂不看

<2.toString equals方法

package dom;

class Person{

 private String name;

 private int age;

 public Person(){};

 public Person(String name,int age){

  this.setName(name);

  this.setAge(age);

 }

 public void setName(String name){

  this.name=name;

 }

 public void setAge(int age){

  this.age=age;

 }

 public String getName(){

  return this.name;

 }

 public int getAge(){

  return this.age;

 }

 public boolean equals(Object obj){

  if(this==obj){//对象的地址

   return true;

  }

  if(!(obj instanceof Person)){

   System.out.println("转换出错..");

   return false;

  }

  Person p = (Person) obj;

  if(this.getName().equals(p.getName()) && this.getAge()==p.getAge()){

   return true;

  }

  return false;

 }

 public String toString(){

  return "姓名"+this.getName()+"，年龄"+this.getAge();

 }

}

public class Text3{

 public static void main(String[]args){

  System.out.println(new Person("王琪",32).equals("lkjklj"));

  System.out.println(new Person("王琪",32).equals(new Person("王琪",32)));

  Object o=new Person("王琪",32);

  Person p=(Person) o;

  System.out.println(p.equals(p));

 }

} 

转换出错..

false

true

true

<4看谁答得最快

package dom.de;

abstract class A{

 public A(){

  this.print();

 }

 public abstract void print();

}

class B extends A{

 private int x=100;

 public B(int x){

  this.x=x;

 }

 public void print(){

  System.out.println("x="+x);

 }

}

public class Text4{

 public static void main(String[]args){

  A a=new B(30);

 }

}

x=0

    子类对象的实例化过程中，先去调用父类中的构造方法，之后再执行子类中的构造方法

    父类的构造方法执行完成之后实际上是为父类中的属性初始化了，但是未执行的话，子类的构造方法就永远不可能调用

    那么子类中所有属性就无法初始化，那么返回的结果就是0；

<5.内部类

package dom;

class Outer{

 private String name="Hello word";

 class Inner{

  public void print(){

   System.out.println("name:"+name);

  }

 }

 public void fun(){

  new Inner().print();

 }

}

public class Text5{

 public static void main(String[]args){

  new Outer().fun();

 }

}

name:Hello word 

感觉很乱但是吧内部类调用到外部

package dom;

class Outer{

 private String name="Hello word";

 public void fun(){

  new Inner(this).print();

 }

 public String getName(){

  return this.name;

 }

}

class Inner{

 private Outer out;

 public Inner(Outer out){

  this.out=out;

 }

 public void print(){

  System.out.println("name:"+this.out.getName());

 }

}

public class Text5{

 public static void main(String[]args){

  new Outer().fun();

 }

}

name:Hello word 

<6. 在类中实例化内部类

    内部类的优点： 在于可以方便的访问外部类中的私有成员

如果要在外部直接使用内部类的实例化对象

    .外部类.内部类  内部对象 = 外部类实例.new 内部类实例();

package dom;

class Outer{

 private String name="Hello word";

 class Inner{

  public void print(){

   System.out.println("name:"+name);

  }

 }

}

public class Text5{

 public static void main(String[]args){

  Outer.Inner in=Outer.new Inner();

  in.print();

 }

}

*************************************

package dom;

class Outer{

 private static String name="Hello word";

 static class Inner{

  public void print(){

   System.out.println("name:"+name);

  }

 }

}

public class Text6{

 public static void main(String[]args){

  Outer.Inner in=new Outer.Inner();

  in.print();

 }

}

    一个内部类如果使用 Ststic 关键字声明的话，次内部类就将成为外部类可以使用外部类.内部类来调用

  Outer.Inner in=new Outer.Inner(); 

<7.方法中定义内部类

    如果可以直接访问外部类，可以直接访问外部类中的各个成员，但是如果要访问方法手中的参数。

    则在参数上要加final关键字修饰

例子1

  package dom;

class Outer{

 private static String name="Hello word";

 public void fun(){

 class Inner{

  public void print(){

   System.out.println("name:"+name);

  }

 }

  new Inner().print();

}

}

public class Text6{

 public static void main(String[]args){

  new Outer().fun();

 }

}          

例子2

package dom;

class Outer{

 private static String name="Hello word";

 public void fun (final int temp){

 class Inner{

  public void print(){

   System.out.println("temp:"+temp);

   System.out.println("name:"+name);

  }

 }

  new Inner().print();

}

}

public class Text6{

 public static void main(String[]args){

  new Outer().fun(30);

 }

}

<8匿名内部类

内部类：在一个类的内部还有另一个类，称为内部类，匿名内部类是在抽象方法和接口的基础之上发展出来的

 例子1：

interface A{

 public void fun();

}

class B implements A{

 public void fun(){

  System.out.println("Hello Word!!");

 }

}

class X{

 public void fun1(A a){

  a.fun();

 }

 public void fun2(){

  this.fun1(new B());

 }

}

public class Text7{

 public static void main(String []args){

  new X().fun2();

 }

}

如果现在假设B类只是用一次，那么还有必要将其定义成一个累吗？

package dom;

interface A{

  public void fun();

 }

class X{

  public void fun1(A a){

    a.fun();

   }

  public void fun2(){

    this.fun1( new A(){

     public void fun(){

      System.out.println("helloword");

     }

    });

   }

 }

public class Text{

  public static void main(String[]args){

    new X().fun2();

   }

}

在一般开发中，java图形界面 Spring开发框架

<9匿名对象

package dom;

class Person{

 private String name;

 private int age;

 public Person(String name, int age){

  this.name=name;

  this.age=age;

 }

 public void tell(){

  System.out.println("name="+this.name+"age="+this.age);

 }

}

public class Text{

 public static void main(String[]args){

  new Person("王琪",20).tell();

 }

}

name=王琪age=20

<8方法的重载

    在方法的操作中有一个特别的概念就是方法的重载，就是指放发名相同，但是参数的类型或个数不同

例子1

package dom;

 public class Text1{

  public static void main(String args[]){

   System.out.println(add1(100,200));

   System.out.println(add2(100,200,300));

   System.out.println(add3(100.3f,200.3f));

 }

 public static int add1(int i,int j){

 int temp =0;

 temp=i+j;

 return temp;

 }

 public static int add2(int i,int j,int k){

 int temp=0;

 temp=i+j+k;

 return temp;

 }

 public static float add3(float i,float j){

 float temp=0;

 temp=i+j;

 return temp;

 }

}

300

600

300.6

但是add方法可以用到重载

package dom;

 public class Text1{

  public static void main(String args[]){

   System.out.println(add(100,200));

   System.out.println(add(100,200,300));

   System.out.println(add(100.3f,200.3f));

 }

 public static  int add(int i,int j){

 int temp =0;

 temp=i+j;

 return temp;

 }

 public static  int add(int i,int j,int k){

 int temp=0;

 temp=i+j+k;

 return temp;

 }

 public static  float add(float i,float j){

 float temp=0;

 temp=i+j;

 return temp;

 }

}

300

600

300.6

以System.;out.println(); 为例子发现了方法的重载

1.这样不算重载

package dom;

 public class Text1{

  public static void main(String args[]){

   System.out.println(add(100,200));

   System.out.println(add(100.3f,200.3f));

 }

 public static  int add(int i,int j){

 int temp =0;

 temp=i+j;

 return temp;

 }

 

 public static  float add(int i,int j){

 float temp=0;

 temp=i+j;

 return temp;

 }

}

以上的方法只是返回值类型不同。

2方法的递归调用

package dom;

 public class Text1{

  public static void main(String args[]){

   System.out.println(add(100));

 }

 public static int add(int x){

 if(x>0){

  return x+add(x-1);

 }

 else{

  return 1;

 }

 }

}

5050

3.方法与数组

  之前的所有操作代码中，所有的方法都是接收了普通的数据类型，当然，一个方法的本身也可以接收引用数据类型

package dom;

 public class Text1{

  public static void main(String args[]){

   int x[]={1,2,3,4,5,6};

   print(x);

 }

 public static void print(int temp[]){

  for(int i=0;i<temp.length;i++){

   System.out.print("temp["+i+"]="+temp[i]+" ")

  }

 }

}

temp 与 x同时操作数组

返回类型的数组

package dom;

 public class Text1{

  public static void main(String args[]){

   int x[]=returnn();

   print(x);

 }

 public static void print(int temp[]){

  for(int i=0;i<temp.length;i++){

   System.out.print("temp["+i+"]="+temp[i]+" ")

  }

 }

 public static int[] returnn(){

  int y[]={2,3,5,4,5};

  return y;

 }

}

4.java中提供了数组排序的方法：

java.util.Arrays.sort(x);

package dom;

import java.util.*;

 public class Text1{

  public static void main(String args[]){

   int x[]={2,3,5,6,5,8,4,2,65,8,52,696,5,4,5};

   java.util.Arrays.sort(x);

   print(x);

 }

 public static void print(int temp[]){

  for(int i=0;i<temp.length;i++){

   System.out.println("temp["+i+"]="+temp[i]+" ");

  }

 }

}

java中提供的数组拷贝方法

/*

 数组一 11 12 33 44 55 66 77 88 99

 数组二 1 2 3 4 5 6 7 8 9

 最后得到 1 2 3 55 66 77 7 8 9

*/

package dom;

import java.util.*;

 public class Text1{

  public static void main(String args[]){

   int x[]={11, 12, 33 ,44, 55 ,66, 77, 88, 99};

   int y[]={1 ,2, 3 ,4 ,5, 6 ,7, 8, 9};

    System.arraycopy(x,4,y,3,3);//原数组 和原数组的开始点，目标数组，目标数组的开始点，个数

   print(y);

 }

 public static void print(int temp[]){

  for(int i=0;i<temp.length;i++){

   System.out.println("temp["+i+"]="+temp[i]+" ");

  }

 }

}

总结：

1 java语言开发的三大分支：

 JAVA SE ：是基础的核心部分

 JAVA EE :   面向企业开发

 JAVA ME : 是java的嵌入式类型

2 java属于编译型和解释型的语言集合

  编译：javac命令 生成*.class文件

  解释 ：java命令 在JVN上进行解释

3java实现可移植性的在jvm上，各个操作系统植入JVM实现程序独立于平台

4java特点 ：可移植性，简单，多线程，面向对象，垃圾回收

5java中有两个重要的环境属性

    path:配置JDK的可执行命令

    classpath配置累的路径，最好配置成.,

    |-SET CLASSPATH=路径

6 public class 和class 的区别

    public class 声明要求类名必须和文件名保持一致

  class 可以不同但是在执行的时候要执行.claass

7java的数据类型划分

  基本数据类型  byte  short long float double boolean char

  引用数据类型  数组 累 接口 引用传递的是内存地址的空间

 8java中的各个操作的符号

9方法是可重复调用的代码，如果各个方法的名称相同，但是参数的类型，个数不同叫方法的重载

10 数据的使用有两步

   声明数组：数据类型 数组名[]=null;

   开辟数组的空间：数组名称=new 数据类型[长度]

11方法可以接收和返回数组

12 java提供了两种操作

  排序：java .util .Array.sort();

     拷贝: System.arraycopy();