java 第三次课—对象、类、包和接口_补充

下面讲解几个重要的修饰符：
1 static
2 this
3 super
4 final
5 abstract
6 接口(interface )
7 内部类(Inner Class )

1 static
class TStatic
{
  static int i;
  void ex1()
  {   i = 4;  }
  static void ex2(int j)
  {   i = j; }
  public static void main(String args[])
  {
    TStatic t = new TStatic();
    t.ex1();
    TStatic.ex2(5);
    System.out.println(t.i);
    System.out.println(TStatic.i);
  }
}

2 this[对象本身]

表示对象本身,在不同方法中表示调用这个方法的对象。在构造方法中表示新创建的对象。

作用：
使用this访问域及方法
使用this解决局部变量与成员变量同名
在构造方法中，用this调用另一个构造方法    [必须放在第一句]
不能通过this引用类变量、类方法

class Person
{
   String name;
   public void ex1(String name)
  {
      //name=name;
      this.name=name;
  }
  public void ex2()
  {
       ex1(“XMJ”);//?
       this.ex1(“XMJ”);//?
   }
}
 //局部变量与成员变量同名

public class A
{
   public A(int i)
   {
        …
    }
    public A(int i,int j)
    {
         this(5);//第一句
         …
     }
     …
}
//调用另一个构造方法

3 super[直接父类]
使用super访问父类被子类隐藏的同名的成员
使用父类的构造方法[super()必须放在第一句]

class A
{
 int i;
 void value()
 {
   i=10;
   System.out.println(i);
 }
}

class B extends A{
  int i;
  void value()
　{
　　i=20;
　　super.value(); //输出i?  i=?
　　System.out.println(i); //i?
　　System.out.println(super.i);//i?
　 }
 }

4 final变量[常量]
  一旦被初始化便不可改变[C++ const]
final方法
  可以继承
  不能被覆盖
final类
   不能被继承

全局常量[定义时赋值]
  public staric final int MAX=100;

 

5 抽象类(abstract )
用关键字abstract修饰的类称为抽象类
 abstract class A //类A为抽象类
 {
    ……
  }

 不能直接被实例化,因此一般作为其它类的父类,定义目的是提供可由其子类共享的一般形式。

 抽象类需要继承,子类根据自身需要扩展抽象类。

abstract能不能和final叠用修饰类？
  类不能同时被声明为abstract和final，因为abstract类中的abstract方法永远没有机会被实现。

抽象类能不能有private成员？
abstract   class中可以有private   method和private   parameter。

抽象方法(abstract )
用关键字abstract修饰的方法称为抽象方法
abstract class A
{
  abstract int aa(int x,int y);//方法aa为抽象方法
}

   在该类中定义但不在该类中提供实现[没有方法体],由继承类提供实现细节。

   抽象类中可以没有抽象方法或某个方法不是抽象方法,有抽象方法的类一定是抽象类[抽象方法只能位于抽象类]。

6 接口(interface )

   如果一个抽象类中的所有方法都是抽象的,就可以将这个类用另外一种方式来定义,也就是接口定义。
   接口是抽象方法和常量值的定义的集合,从本质上讲，接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现。

   可以使用extends来继承接口的常量和抽象方法，但它与类中的extends不同，它可以继承有多个父接口(多重继承)，各父接口间用逗号隔开。
   接口中的所有常量必须是public static final，方法必须是public abstract，这是系统默认的，不管你在定义接口时，写不写修饰符都是一样的。

定义接口
修饰符 interface 接口名 [extends 父接口列表]
   {
      常量域声明
      抽象方法声明
}

实现接口
  implements
  一个类可以实现若干个接口
  非抽象类必须实现所有的抽象方法

//例一
interface AnimalAction
{
  public void shout ();
}
class cat implements AnimalAction
{
   public void shout ()
   {
       System.out.print(“喵喵”);
    }
}

 

//例二
interface prt
{
  public void prtln();
}
class A implements prt{
  int a = 3;
  public void prtln()
 {
    System.out.println(a);
  }
}
class B implements prt{
  int b = 4;
  public void prtln()
  {
    System.out.println(b);
  }
}

public class MyInterfaceDemo
{
  public static void dost(prt c)
  {
    c.prtln();
  }
  public static void main(String[] args)
  {
    A a1 = new A();
    B b1 = new B();
    MyInterfaceDemo.dost(a1);
    MyInterfaceDemo.dost(b1);
  }
}

 

7 内部类(Inner Class )
     Java内部类内部类：从表面上看，就是在类中又定义了一个类。[C++ 嵌套类(Nested Class)]
一个内部类的对象能够访问创建它的外部类对象的所有属性及方法(包括私有部分)。
对于同一个包中的其它类来说，内部类能够隐藏起来。(将内部类用private修饰即可)
内部类可定义在方法中,称为局部内部类，但它只能使用方法中的final常量。
非静态内部类不能声明本类的static成员。

JAVA内部类的分类：

1.创建内部类实例必然先创建一个外部类的实例
2.内部类的实例自动获得外部类的实例的引用，因此，可以直接访问外部类的所有成员。
3.外部类实例不能直接访问内部类的成员，必须通过实例访问。
4.实例内部类中只能定义实例成员，不能定义静态成员。
5.如果内部类和外部类命名冲突，this表示内部类的对象，访问外部类对象是用类名.this

   内部类是Java语言中的一种特殊的语法，简单的来说，就是在一个类的内部再声明一个类，这些声明在类内部的类就被称作内部类。在实际声明时，内部类可以声明在类的内部、类的方法内部，也可以声明在类的构造方法内部，内部类声明的语法格式和一般类的声明一样，只是内部类声明时可以使用static修饰符进行修饰。

public class OutClass {
         int i = 0;
        public class InnerClass{
                public void test(){
                            i++;
                   }
         }
}

静态内部类  用static 修饰

1.静态内部类不需要创建外部类的引用
2.静态内部类可以直接访问外部类的静态成员，如果访问非静态成员，必须通过实例访问。
3.静态内部类可以定义静态成员和实例成员。
4.可以直接通过完整类名访问静态内部类的静态成员。

public class StaticInnerClass {
int x=100;
static class Inner{
void doitInner(){
//System.out.println("外部类"+x);????//调用外部类的成员变量x
}}}

在内部类的doitInner()方法中调用成员变量x，由于Inner被修饰为static形式，而成员变量x却是非static类型的，所以在doitInner()方法中不能调用x变量。

局部内部类
    定义在方法中的内部类，可见范围是当前方法。

1.局部内部类只能在当前方法中使用。
2.不能包含静态成员。
3.不能有权限控制修饰符。
4.访问的成员必须是final

匿名类
    是一种特殊的内部类。

1.匿名类没有构造方法，但可以调用父类的
2.尽管没有构造方法，但可以提供一段初始化代码块，但不允许重载。
3.除了可以在方法中定义匿名类，还可以在声明成员属性时定义。
4.除了继承类外，还可以实现接口。

public class Outer
{
 private int i;
 public class Inner
 {
   private int i;
   public void doStuff(int i)
   {
    i++;
    this.i++;
   Outer.this.i++;
  }
 }
}

class Outer
{
  public class Inner
  {
    public void doStuff()
    {…}
  }
}
public class TestInner
{
  Outer outer=new Outer();
  Outer.Inner inner
               =outer.new Inner();
  inner.doStuff();
}