类的高级概念

访问修饰符：
           本类        同包            不同包
                    子类非子类     子类   非子类
private     是       否     否        否      否
默认        是       是     是        否      否
pretected   是       是     是        是      否
public      是       是     是        是      是

package com.lovo.home;

public class MySelf {

public int a = 10;

private int year;

private int month;

private int day;

public int getA() {
  return a;
}

public void setA(int a){
  if(a >= 0){
   this.a = a;
  }
}

public String getBirthday(){
  return year + "-" + month + "-" + day;
}

public void setBirthday(String birthday){
  //拆分字符串，分别取出年月日,给year、month、day进行赋值
}

public void test(){
this.a = 100;
}
}

package com.lovo.home;

public class Son extends MySelf{

public void test(){
  System.out.println(this.getA());
  this.setA(-10);

  this.getBirthday();
  this.setBirthday("1990-9-9");
}

}

package com.lovo.home;

public class Wife {

public void test(){
MySelf me = new MySelf();
me.a = 100;
}

}

package com.lovo.outside;

public class Daughter extends MySelf{

public void test(){
this.a = 100;
}

}

package com.lovo.outside;

public class Stranger {

public void test(){
MySelf me = new MySelf();
me.a = 100;
}

}

封装：访问修饰符的作用是限制属性和方法被使用和调用的范围
好处：1、类的成员变量可以成为只读或只写
2、类可以对存储在成员变量中的内容有一个整体的控制
3、类的用户不需要知道类是任何存储数据的

public class TestMain {

/**
* @param args
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub
  new Human();
  new Man();


}

}

public class Human {

{
  System.out.println("父类实例初始化块！");
}

static{
  System.out.println("父类静态初始化块！");
}

public Human(){
  System.out.println("父类构造方法！");
}

public void dance(){
  System.out.println("迪斯科");
}

}

public class Man extends Human{
//初始化块
//实例初始化块--在产生对象的时候自动执行,在父类的构造方法之后，本类的构造方法执行之前
//使用量很少，因为完全可以把代码就写到本类构造方法的前几行
{
System.out.println("子类实例初始化块！");
}
//静态初始化块--在类加载的时候自动执行，只会执行一次
//使用量很高，通常会把一些程序运行前的准备工作放在这里，让其在加载期就完成准备
static{
System.out.println("子类静态初始化块！");
}

//属性
public int a;
public static int b;

//构造
public Man(){
  System.out.println("子类构造方法！");
}

//方法
public void aa(){

}

public static void bb(){

}

}

static修饰符：与对象无关，与类有关，全类共享一个值，预加载

1、static的方法不能操作非static的任何属性和方法
2、非static的方法能操作static的属性和方法

static不能用来修饰构造方法，因为构造方法是用来产生对象的

常量加static修饰，工具类的工具方法也可以加static

public class Student {

//用static修饰的属性，所有Student对象共用
//在加载期首先被产生在数据段的静态区中
public static int num = 0;

public String name = "zhao4";

public int age;

//static不能修饰构造，因为凡是static的都与对象无关，而构造是专门用来产生对象的
public Student(){
  num++;
}

//static的方法不能操作非static的任何属性和方法
//原因：1、从设计上来说，static是类级别。与对象无关；
//    2、从实现上来说，static修饰的是被首先加载的，此时非static的还没有被加载到内存，所以无法访问。
//什么时候用static修饰呢？---工具类的工具方法
public static void test(){
  System.out.println("静态方法！");
}

//非static的方法是可以操作static的任何属性和方法
public void hello(){
  this.test();
}

}

实例初始化块：在产生对象的时候自动执行，在父类的构造方法之后，在子类构造方法之前执行；可以放在本类构造方法前几行

静态初始化块：在类加载时自动执行，只会执行一次。同常把程序运行前的准备工作放在这里，让其加载期就完成准备

内部类：在Java中还可以在类的内部定义类；在类的内部定义的类叫内部类，内部类所在的类叫外部类

规则：
1、成员内部类：在方法之外，有访问修饰符；class文件名：外部类类名$内部类类名.class
   局部内部类：在方法之内，没有访问修饰符；class文件名：外部类类名$+序号+内部类类名.class
2、内部类拥有类的所有功能，是一个完整的类
3、局部内部类只在方法中起作用
   成员内部类在任意本类非static方法中都可以new出来，但在第三方类必须用“外部类对象.new 内部类名（）”产生内部类对象
   static内部类在本类的任意方法中都可以new出来，在第三方类中要new出来无需产生外部类对象只需用“外部类.内部类（）”
4、匿名内部类：局部内部类的特例
       由于没有类名所以是在产生对象时用语句告诉JVM它的结构，只能用一次
       class文件名：外部类类名$+序号.classs
注意括号、分号的位置：
    newobject(){
        public void Hello(){
             this.World();
           }
        private void World(){
           }
      }.Hello();

public class TestMain {

/**
* @param args
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub
  OutClass out = new OutClass();
  out.a = 1000;

  InnerClass1 inc1 = out.new InnerClass1();
  OutClass.InnerClass3 inc3 = new OutClass.InnerClass3();
}

}

public class OutClass {

public int a = 10;//成员变量
public static int aa = 10;

//成员内部类
//1、可以有访问修饰符;
//2、class文件的名字：外部类类名$内部类类名.class
//3、就是一个完整的独立的类
//4、在本类的任意非static方法中都可以new出来；在第三方类中必须用外部类对象.new的方式产生内部类对象
public class InnerClass1{
  private int innerA;

  public InnerClass1(){

  }

  public int getInnerA() {
   return innerA;
  }

  public void setInnerA(int innerA) {
   this.innerA = innerA;
  }
}

//静态内部类
//在本类的任意方法中都可以new出来；在第三方类中要new出来，无需产生外部类对象，只需用外部类类名.的方式就可以了。
public static class InnerClass3{
  private int innerC;

  public InnerClass3(){

  }

  public int getInnerC() {
   return innerC;
  }

  public void setInnerC(int innerC) {
   this.innerC = innerC;
  }
}

public void test(){
  int b = 10;//局部变量
  //局部内部类
  //1、不能有访问修饰符
  //2、class文件的文字：外部类类名$序号+内部类的类名.class
  //3、就是一个完整的独立的类
  //4、在本方法内可以产生对象，然后使用。
  class InnerClass2{
   private int innerB;

   public InnerClass2(){

   }

   public int getInnerB() {
    return innerB;
   }

   public void setInnerB(int innerB) {
    this.innerB = innerB;
   }
  }

  b = 100;
  InnerClass2 inc2 = new InnerClass2();
  InnerClass1 inc1 = new InnerClass1();
  InnerClass3 inc3 = new InnerClass3();

  //匿名内部类--局部内部类的特例
  //由于没有类名，所以是在产生对象的时候用语句告诉JVM它的结构
  //只能用1次！
  //注意分号，括号的位置
  new Object(){
   public void hello(){
    System.out.println("我不是Object，我是他儿子！");
    this.world();
   }

   private void world() {

   }
  }.hello();

  Human hu = new Human(){
   public void dance(){
    System.out.println("恰恰");
   }
  };

  hu.dance();

}
}

posted @ 2016-02-24 21:58 DAILU 阅读(128) 评论(0) 收藏举报

刷新页面返回顶部

DAILU

类的高级概念

公告