面向对象第五天（Java）

面向对象第五天（Java）

主要内容：

代码编写中的一些基本知识

外部类与内部类

1、包：允许类组成较小的单元，易于找到和使用相应的文件
      防止命名冲突
      更好的保护类，属性和方法。
   package com.hwadee.ttip;
   包命名规范：
      包名由小写字母组成，不能以圆点开头和结尾。
      包名之前最好加上唯一的前缀，通常使用组织机构倒置的网络域名， 如：www.edu.cn         package cn.edu.mypackage;
  包名后续部分依不同机构内部的规范不同而不同
   package cn.edu.javagroup.powerproject;
为了使用不再同一包中的类，需要在java程序中使用import关键字导入这个类import java.util.*;和import cn.edu.ttip.UserService;
语法：import 包名.类名；
2、final和static
  (1)final
     ①final表示“最终”
      final在类之前：表示该类不能被继承
      final在方法之前：表示该方法不能被覆盖
      final在变量之前：定义一个常量
     ②final类

//这是一个final类，它不可被子类继承
    public final class FinalClass {
    //这是常量定义，表示值不可更改
    public final double PI=3.1415;
    }
    //子类不可以继承final类
    /*
    class SubFinalClass extends FinalClass{
    }
    */

     ③final方法：

public class FinalMethod {
    //方法不能在子类中被重写
    public final double Division() {
        return 1.0;
    }
    }
    //演示子类不可重写final方法
    class SubFinalMethod extends FinalMethod{
    /*
    @Override
    public double Division() {
        // TODO Auto-generated method stub
        return super.Division();
    }*/
    }

     ④final类和abstract类：abstract类不能直接产生属于这个类的对象，只有创建子类后才可以实例化。final类不能被其他任何类所继承。


(2)static
    static在变量或方法之前，表明他们属于类范围的，称为类方法（静态方法）或类变量（静态变量）
    若变量或方法之前无static修饰，则是实例方法和实例变量
  ①静态属性：
     类变量在各个实例间共享
     类变量的生存期不依赖于对象，相当于c语言中的全局变量的作用，其他类可以不通过实例化访问他们。

public class StaticVar {
        public static int number=3;

    }
    public class OtherClass {
        public void method() {
            int x=StaticVar.number;
    }

    }

  ②静态方法：
 类方法相当于C语言中的全局函数，其他类不用实例化即可调用他们。

public class GeneralFunction {
    public static int addUp(int x,int y) {
        return x+y;
    }
    }
    public class UseGeneral {
    public void method() {
        int a=9;
        int b=10;
        int c=GeneralFunction.addUp(a, b);
    }
    }

  ③静态变量/方法和实例变量/方法
    静态变量/方法都是使用类名引用
    实例变量/方法必须先创建实例对象，然后使用实例对象引用

public class StaticAndInstanceDemo {
    private int id=1;  //实例变量
    public static int number=3; //静态变量

    public int getId() {  //实例方法
        return this.id;
    }

    public static int addUp(int x,int y) { //静态方法
        //this.id;     //在静态方法中不能使用this
        return x+y;  //在静态方法中只能访问静态变量或者静态方法
    }

    }

  ④完整例子

//static是违反了面向对象原则的。
    //所有静态变量、静态方法的使用都不需要创建对象实例
    public class StaticClass {
    //静态代码块
    //这些代码在加载类的字节码后立即执行，不需要创建对象实例
    static {
        System.out.println("static block 2");
    }
    static {
        System.out.println("static block 1");
    }
    //静态变量保存在方法区，由所有的对象实例所共享
    //静态变量类似于全局变量，在并发环境中会出现同步问题。
    //在面向对象编程中不应该使用静态变量，如果要使用static修饰变量，通常和final配对使用来定义常量。
    public static final double PI=3.1415;
    private int i;

    public StaticClass() {
        System.out.println("构造方法被调用");
    }

    //静态方法
    //直接使用“类名.静态方法名”调用
    //静态方法中不可以使用this，因为它执行时并不需要对象存在。
    public static void method1() {
        System.out.println("静态方法被调用");
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("StaticClass.PI:"+StaticClass.PI);
        StaticClass.method1();
    }

    }

3、内部类：
  在面向对象程序设计中，可以在一个类的内部定义另一个类，即内部类；
  内部类有两种类型：静态内部类、非静态内部类（普通内部类），静态内部类使用很少，最重要的是普通内部类
  使用内部类可以隐藏实现细节，也可以让代码更加简洁。
(1)普通内部类：
  内部类几乎可以处于内部的任意位置，可以与实例变量处于同一级，或处于方法之类，甚至是一个表达式的一部分。
  普通内部类和平时的类定义没有什么不同，主要是内部类可以访问外部类的属性和方法，这里的语法和平时有些不同。

//普通内部类的定义
public class Forest {
    //成员变量
    private int sum_tree=1000; //树的总数
    private int type_tree=100; //树的类型

    //成员方法
    public int getTreeType() {
        return type_tree;
    }

    /*
     * 普通内部类的演示
     * 1、普通内部类也是类，可以有自己的成员变量，成员方法
     * 2、普通内部类可以访问外部类的成员方法和成员属性。
     */

    //动物
    class MagicalAnimal{
        private String name;  //动物名称

        public void setName(String name) {
            this.name=name;
        }
        //内部类访问外部类的属性
        public int getTreeSum() {           
            return Forest.this.sum_tree; //语法上要求使用"Forest.this"表示Forest
        }
        //内部类访问外部类的方法
        public int getTreeType() {
            return Forest.this.getTreeType(); //语法上要求使用"Forest.this"表示Forest
        }
    }   
}

    //普通内部类的使用
    public class ForestClient {

    //演示内部类的创建和调用
    public static void main(String[] args) {
        /*
         * 1、普通内部类的创建：普通内部类必须依赖于外部类的实例而存在
         *   1），首先创建外部类
         *   2）、使用外部类的实例创建普通内部类。注意创建语法：f.new 这里的f指的是外部类的实例
         * 2、普通内部类的使用：和通常类的用法一样
         */

        //Forest f=new Forest();
        //Forest.MagicalAnimal man=f.new MagicalAnimal();
        Forest.MagicalAnimal man=new Forest().new MagicalAnimal();


        man.setName("Monkey"); //普通内部类的成员方法
        System.out.println(man.getTreeSum());//普通内部类的成员方法
        System.out.println(man.getTreeType());//普通内部类的成员方法
    }

    }

(2)静态内部类
  静态内部类和普通内部类，从形式上看区别不大，但是访问内容的差别是比较大的。
  ①在内部类定义的前面有static限定，例如：static class A
  ②在静态内部类中，也可以有实例变量和实例方法；但是在普通内部类中，不能有静态变量和静态方法。
  ③在静态内部类中，访问外部类的静态变量和静态方法，和其他类中访问外部类的静态变量和静态方法没有区别

    //静态内部类的定义：
    public class Forest {
    //成员变量
    private int sum_tree=1000; //树的总数
    private int type_tree=100; //树的类型

    //成员方法
    public int getTreeType() {
        return type_tree;
    }
    //静态变量，用于静态内部类
    private static int staticValue=10000;
    //用于静态内部类
    public static int getTreeSum() {
        return 1000;
    }

    /*
     * 普通内部类的演示
     * 1、普通内部类也是类，可以有自己的成员变量，成员方法
     * 2、普通内部类可以访问外部类的成员方法和成员属性。
     */

    //动物
    class MagicalAnimal{
        private String name;  //动物名称

        public void setName(String name) {
            this.name=name;
        }
        //内部类访问外部类的属性
        public int getTreeSum() {           
            return Forest.this.sum_tree; //语法上要求使用"Forest.this"表示Forest
        }
        //内部类访问外部类的方法
        public int getTreeType() {
            return Forest.this.getTreeType(); //语法上要求使用"Forest.this"表示Forest
        }
    }
    /*
     * 静态内部类
     * 1、静态内部类也是一个类，前面使用static修饰，可以有成员属性，成员方法
     * 2、在静态内部类中不能访问外部类的成员变量和成员方法，但是可以访问静态变量和静态方法。
     */
    static class A{
        private int i=1;
        public int getI() {
            return i;
        }
        /*
        public int getTreeSum() {
            return Forest.this.sum_tree;  //静态内部类不能访问外部类的成员变量
        }*/

        public int getStaticValue() {
            return Forest.staticValue;   //静态内部类能访问外部类的静态变量
        }
        /*      
        public int getTreeType() {
            return Forest.this.getTreeType();  //静态内部类不能访问外部类的成员方法
        }*/
        public int getTreeSum() {
            return Forest.getTreeSum();  //静态内部类能访问外部类的静态方法
        }
    }

    }

    //静态内部类的使用
    public static void main(String[] args) {
        /*
         * 1、静态内部类的创建：静态内部类不需要依赖于外部类的实例
         *   1）直接创建静态内部类，
         */

        Forest.A  a=new Forest.A(); //静态内部类的创建方法，不需要外部类的实例。
        System.out.println(a.getI());
        System.out.println(Forest.A.getValue());
    }