黑马程序员技术交流社区

标题: java总结笔记 [打印本页]

---

作者: MengDeKaiShi    时间: 2015-1-2 22:24
标题: java总结笔记
1.        包（package）
对类文件进行分类管理，给类提供多层命名空间，类名的全称是包名.类名
包也是封装的一种体现
格式：package包名，全部小写，可以多级
写在程序第一行.（先package 再import 最后定义class或interface ）
编译运行：（1）方式一：手动建包，自己建文件夹，然后java 包名.类名来
                                                        执行
                          （2）方式二：自动建包 javac –d . java文件 –d后面的“.”
                                                        代表当前目录
被访问的包中类的权限必须是public
2.        类的访问权限修饰符
(1)private 类访问权限:本类内部可以访问,不能继承到子类;
(2)default 什么都不写,包访问权限:本类内部可以访问，同包其他类也可以访问,同包可继承;
(3)protected 子类访问权限:本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问,能继承到子类;
(4)public 公共访问权限:任何地方都可以访问,能继承到子类;



3.        import
当用到某个包中类的时候，用import关键字把包中的类导入，这样就不用每次写包名，方便了操作，简化了书写。
一个程序文件中只有一个package但是可以有多个import
4.        内部类
将一个类定义在另一个类的里面，里面的那个类就称为内部类（内置类、嵌套类）
（1）成员位置——成员内部类。可以被private、 static修饰，被static修饰的内部类只能访问外部类的静态成员出于安全性考虑，可以将内部类定义为private，然后在外部类中提供一个访问内部类方法的公共方法供外界调用。
        /***************************************************************/
/*
内部类调用外部类成员：当成自己的成员来用

外部类调用内部类： 实例化一个内部类对象使用
                                  内部类名 对象引用=new内部类名();

在测试类中直接调用内部类：
                                外部类名.内部类名 变量=外部类对象.内部类对象


成员内部类编译后.class文件的名字格式：外部类$内部类.class
*/
class Outer
{
        private int num=10;

        //定义一个内部类Inner
        class Inner
        {
                //定义一个内部类方法
                public void show()
                {
                        System.out.println(num);
                }
        }
        /*
        若内部类中存在静态的方法，那么内部类也必须是静态的，
因为静态随着类的加载而加载，当外部类文件加载时，静态方法也需要被加载，
但是包含静态方法的那个内部类不是静态的，不会被加载，这就会产生冲突
因此，包含静态方法的内部类也需要是静态的，让他能随着外部类的加载而加载
        */
    //定义一个静态内部类Inner2
        public static class Inner2
        {
                public void show()
                {
                        System.out.println("show");
                }
                //定义一个静态的内部类方法
                public static void staticShow()
                {
                        System.out.println("static method show");
                }
        }

        //外部类的方法method
        public void method()
        {
                Inner in=new Inner();
                in.show();
        }
}

class InnerTest
{
        public static void main(String[] args)
        {
                Outer out=new Outer();//实例化外部类对象out
out.method();//调用外部类的method方法来调用内部类的show()
               
                //直接使用内部类的方法
                //格式：外部类名.内部类名 变量=外部类对象.内部类对象
                Outer.Inner in=new Outer().new Inner();//实例化内部类
                in.show();//调用内部类方法show();

                //如果内部类是static修饰，调用格式为
                //外部类名.内部类名 变量=new 外部类名.内部类名（）
                Outer.Inner2 in2=new Outer.Inner2();//实例化静态内部类
                in2.show();//调用内部类的非静态方法show()
                //由于静态方法可以通过类名调用，所以staticShow()调用为
                Outer.Inner2.staticShow();
        }
}
        /***************************************************************/

（2）局部位置——局部内部类。也可以直接访问外部类中的成员，同时可以访问局部成员，但是必须是被final修饰的局部成员
        /***************************************************************/
/*
局部内部类访问局部变量，该变量必须被final修饰。
原因：局部变量在栈内存，方法调用完毕就从栈中消失。而局部内部类
存储在堆中，随着对象消失而消失。为了延长局部变量的声明周期，所以要加final修饰

局部内部类可以看做方法中定义的局部变量，只有在方法中进行实例化操作并使用

局部内部类编译后.class文件的名字格式：外部类$1内部类.class

*/
class Outer
{
//外部类成员变量
        private int num = 10;

        public void method()
        {
                //局部变量
                final int num2=100;
                //定义局部内部类
                class Inner
                {
                        public void show()
                        {
                                System.out.println(num);
                                System.out.println(num2);
                        }
                }
                //创建内部类对象，调用show()方法
                Inner in=new Inner();
                in.show();
        }
}
    //测试类
class InnerTest2
{
        public static void main(String[] args)
        {
                Outer out=new Outer();
                out.method();
        }
}
        /***************************************************************/
（3）匿名内部类——没有名字的局部内部类。
                前提：必须存在一个类，抽象类或者接口
                格式：new 类名或者接口名（）
                                {
                                        重写类或者接口中的方法。
                                        也可以自己定义新的方法。
}；
        /***************************************************************/
/*
        匿名内部类
        格式：new 类名或者接口名（）
        {
                重写类或者接口类中的方法。
                也可以自己定义新的方法。
        };

        理解：是一个继承了类或者实现了接口的匿名的子类对象。
       
        什么情况下使用匿名内部类？
        一般来说，当接口或者抽象类中的方法在3个以下的时候，
        考虑使用匿名内部类。
        以后当看到一个方法接收的形式参数是一个抽象类或者接口时，
        就可以考虑用匿名内部类
*/

//定义一个接口，通过匿名内部类去实现它
interface Inner
{
        public abstract void show();
}
//定义一个外部类
class Outer
{
        public void method()
        {
                //定义匿名内部类实现Inner接口
                //实质上，就是一个实现了Inner接口的子类的匿名对象
                new Inner()
                {
                        public void show()
                        {
                                System.out.println("show");
                        }

                        public void show2()
                        {
                                System.out.println("show2");
                        }
                };

                //调用方式
                new Inner()
                {
                        public void show()
                        {
                                System.out.println("show");
                        }
                        public void show2()
                        {
                                System.out.println("show2");
                        }
                }.show();//调用show()方法

                new Inner()
                {
                        public void show()
                        {
                                System.out.println("show");
                        }
                        public void show2()
                        {
                                System.out.println("show2");
                        }
                }.show2();//每次调用一次方法都需要以这种方式，太麻烦
               
                //调用方式改进(多态的形式)
                Inner in=new Inner()
                {
                        public void show()
                        {
                                System.out.println("show");
                        }
                };//定义父类引用指向子类对象
                in.show();//调用子类的show()方法
        }
}

//测试类
class InnerTest3
{
        public static void main(String[] args)
        {
                Outer out=new Outer();
                out.method();
        }
}
/***************************************************************/

/******************匿名内部类使用情况示例**********************/
//定义一个接口Animal
interface Animal
{
        public abstract void eat();
}

//一个实现了Animal接口的子类对象
class Dog implements Animal
{
        public void eat()
        {
                System.out.println("Dog eat");
        }
}

class Test
{
        //定义一个形参是接口（或抽象类）的方法
        public void show(Animal a)
        {
                a.eat();
        }
}
class InnerTest4
{
        public static void main(String[] args)
        {
                Test t=new Test();
               
                //第一种调用方式，实例化接口的子类对象作为参数传递
                Dog d=new Dog();
                t.show(d);

                //第二种方式，传递匿名内部类作为参数
                t.show(new Animal()
                        {
                                public void eat()
                                {
                                        System.out.println("匿名动物吃饭");
                                }
                        });//只使用一次的时候，第二种方式比较简便
        }
}

---

作者: xc29417412    时间: 2015-1-2 22:26
你这也太那啥了，一个字，好

---

作者: Jason996    时间: 2015-1-2 22:32
楼主总结的很细。学习了！

---

作者: jun_03    时间: 2015-1-2 22:35
继续马克，以后也是学这个的，有用。:lol

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2