Java中类与方法的学习笔记（一）：

关于JAVA中类与方法的学习笔记（一）：
（笔者是一个计算机的学生，四年没怎么用功，所以在JAVA语言的认知上很模糊，接近小白但又不是小白。下面的总结记录完全是按照笔者个人的认知范围和重要程度叙述，如有不妥恳请指出。）
笔者先是对于类，方法，对象的认知模糊了。具体的概念不赘述，下方有详细链接
这里是原文地址，更为详细，以下内容为转载引用

对于三者的关系，形象的举个例子：人，是一个类。打酱油，是人的一个动作， 也就是方法。小红是人的一个对象。让小红去打酱油，就是调用了人的 “打酱油” 方法

根据上述释义，转换为代码如下 – 例.1

class man{  //定义 man 这个类    public void dajiangyou(){ //定义“打酱油”这个方法        System.out.println("打酱油");    }    public static void main(String arg[]){//主函数        man xiaohong = new man();//实例化一个对象 “小红”        xiaohong.dajiangyou();//调用man类的方法--“小红.打酱油”    }}

笔者看到这里，觉得此人的比喻真是妙哉！但转而又产生了疑惑，static,public,void,class,new 这些词到底啥时候该用，啥时候不该用。搜了搜，小小总结下，抽象方法抽象类未写，造化不够（笔者仅表述个人理解的粗略意思，如有错误还请指出更正）
1. class:用来声明和定义类
2. new:用来开辟堆内存，又叫初始化，一般情况下，对象创建好后，都需要用new进行实例化
3. void:我知道这个东西附带在类声明上，是代表该函数没有返回值，就是不用写return呗
4. public:一提到它，就得说private,protected.这应该是类作用范围的问题。稍后说
5. static:用来静态修饰成员变量和成员方法。
紧接着问题就来了
问题1：为啥有的类前面有public，有的没有。
答：我的理解，一个类文件下可以有多个类，但是有且只有一个public类，且名称要和文件名一致。public只是class的一种修饰词，表示公开的类，方便其他类的引入使用。谈到这里又要说到刚才的问题，问题2
问题2：public,protected,private的区别
答：刚才也说了public只是class的一种修饰词，表示公开的类。
protected，表示受保护的类，子孙类和本类可引入使用。
（friendly）默认不写，表示同包中和本类中可使用
private，表示私人的，只能在本类中使用
这篇回答介绍的很详细

————————-分割线——————————
问题都是接踵而至的，这里我也不太好描述，干脆直接说我遇到的问题和自己的理解吧。
java方法的定义：

访问修饰符 返回值类型 方法名（参数列表）{
        方法体
}

这里如果没有返回值，自然就是用void代替返回值的类型。查询了一下java方法，有说分为三类：构造方法（构造器）,成员方法（一般方法），静态方法。
在new对象时，需要有构造方法，我当时费解这个方法怎么没有void也不用返回参数了。一查原来是构造函数。

构造方法的作用是给初始化的对象赋值，如果你想给创建的对象的属性一开始就定义成一些值就需要有参构造方法，如果只是默认值，就是无参构造方法。构造方法是规定的，不用void无返回值；

成员方法是指一般方法，比如例.1中的dajiangyou()。如所见，成员方法的调用要通过实例化对象来做，所以有如下代码

        man xiaohong = new man();//实例化一个对象 “小红”        xiaohong.dajiangyou();//调用man类的方法--“小红.打酱油”

静态方法，在我理解就是有static声明的。对于static，印象比较深是主函数里面带的有~~从上java课开始，就被老师告诉要牢记主函数的声明方式，既然说到主函数，咱就插一嘴

关于主方法
1、主方法是静态方法，所以如果要在主方法中调用其他方法，则该方法也必须要是静态的（static声明的）；
2、主方法是没有返回值的；
3、主方法的参数为数组args，其个数为args.length；
4、一个程序要运行必须有主方法的存在。
5、主方法是类的入口点，它定义了程序从何处开始，主方法提供对程序流向的控制，Java编译器通过主方法来开始执行程序。其一般定义方法如下：
public static void main（String[] args）{
//方法体
}

用static修饰的方法叫静态方法。静态方法不需要new出对象引用来调用，它可以用类名直接调用。当然用对象引用也能调它，只是不需要。
这里引入一个例子：
例.2

public class Demo {    private static void a(){        System.out.println("静态方法a");    }    private void d(){        System.out.println("成员方法d");    }    public static void main(String[] args) {        a();//可直接调用        Demo demo = new Demo();//通过new对象来调用        demo.d();    }}

例.2展示了成员方法和静态方法的调用区别。静态方法不需要new出对象引用来调用，它可以直接用类名直接调用。成员方法则必须用对象引用进行调用。

class Outter {    static class Inner //内部类    {        public void innerShow() //内部类的成员方法        {            System.out.println("调用了内部类的成员方法innerShow()!!!");        }        public static void innerShower()//Inner.shower可以在Outter类中调用该方法        {            System.out.println("调用了内部类的静态方法innerShower()");        }    }    public void getInner() //外部类的成员方法  需要实例Outter对象，再调用    {        //在外部类中创建内部类对象        Inner ii = new Inner();        ii.innerShow();//实例化调用        Inner.innerShower();//类名直接调用    }    public static void outterStatic()   //外部类的静态方法  直接用类名.outterStatic()调用    {           System.out.println("调用了外部类的静态方法outterStatic()!!!");    }}//主类public class host//主类{    public static void main(String[]args) //主函数    {        //在外部类外创建静态内部类的对象        Outter.Inner i =new Outter.Inner();        i.show();        //new Outter.Inner().show();同上一样的效果        Outter.Inner.shower();//直接调用Outter类下inner类的shower方法        //在外部类中使用静态内部类的对象        Outter t = new Outter();        t.getInner();        //new Outter().getInner();同上一样的效果        Outter.outterStatic();//直接调用        hostStatic();//不用类名，直接调用    }    private static void hostStatic() {        System.out.println("调用了主类中的静态show()!!!");    }}

这貌似是个很脑残的例子，我主要就是想试试类中各方法的调用
一共有如下几个方法：

1. hostStatic() 主类里的静态方法，直接用hostStatic()调用
2. outterStatic() 外部类里的静态方法，类名.OutterStatic()调用
3. innerShow() 内部类里的成员方法，实例化Outter.Inner对象，再调用方法
   Outter.Inner i =new Outter.Inner();
i.show();
new Outter.Inner().show();//该句一样的效果
4. innerShower() 内部类里的静态方法。Outter.Inner.innerShower()直接调用;
5. getInner() 外部类里的成员方法，通过实例化Outter对象，调用getInner方法达到执行innerShow，innerShower的方法
   Outter t = new Outter(); t.getInner(); //new Outter().getInner();同上一样的效果

关于外部类，内部类，匿名类的一点说明
1. 外部类就是两个类并列的class A {} class B {}
2. 内部类：class A { class B{}}.B可以直接使用包含它的类的成员变量，内部类不能被除包含类以外的类调用；
3. 匿名类，也是内部类 classA{new{}}省略定义类名直接定义方法和使用，这个适用于代码比较简单且这个类不需要被其他类调用

同时这里还得穿插new的一点问题。
new A.B()是创建B对象，A应该是包名。
new A().B()是创建A对象，并且调用A类中的B方法，例.2出现一个 new Outter.Inner().show()类似于该形式，Inner是Outter的子类。
new A(newB())这个是先newB对象，这个B对象不一定在A对象里面。再根据new出的B对象newA对象，并且两者不一定存在什么联系

暂时写这么多~~~
————————&&&——————-2016.3.14晚

上面总结静态方法的知识点，过于局限了，对于静态方法在运用时产生了一些疑问，所以又过来写清楚。

静态方法只能访问静态成员，实例方法（成员方法）可以访问静态和实例成员。
为什么“静态方法不能调用类成员变量”，因为要想访问成员变量你必须有个“已经实例化好的对象”，而静态方法在执行时，并不一定存在对象，除非你在静态方法里创建一个当前类的实例对象，否则你是无法直接调用成员变量的，因为它不知道这个成员变量属于哪个实例对象的。同样的道理，静态方法中也不能使用关键字this。
main()方法是一个典型的静态方法，它同样遵循一般静态方法的规则，所以它可以由系统在创建对象之前就调用。

看下面的例子
例.3

public class StaticTest{    private static int sa; //定义一个静态成员变量    private int ia;  //定义一个实例成员变量    public static void main(String[] args) {//main函数本身是一个静态函数        sa = 10;        //正确,可以直接调用静态成员变量        ia = 10;       //错误，不能直接调用实例成员变量        insMethod();    //错误，不能直接调用        StaticTest test = new StaticTest();//实例化当前类的对象        test.ia = 10;   //正确  实例化后调用        test.insMethod(); //正确 实例化后调用        statMethod(); //正确 静态方法直接调用        StaticTest.otherStat(); //正确 同上句话一样的效果，在当前类下StaticTest可省略    }    //下面定义一个静态方法    static void statMethod(){        otherStat();  //正确  调用静态方法        i = ia + 20;  //错误 不能直接调用实例成员变量        insMethod();  //错误 不能直接调用实例方法    }    static void otherStat(){        //这里也是一个静态方法    }     //下面定义一个实例方法     void  insMethod(){        int i = 0;         i =  sa + 15; //实例方法里可以直接调用静态变量        ia = 30;      //实例方法里可以直接调用成员变量        statMethod(); //正确  调用静态方法    }} 

我认为这些文章可以帮到你
Java 中，为什么在静态方法中可以调用的方法、可以使用的成员变量必须是静态的？
java 静态方法和实例方法的区别
Java中同类中的静态方法能否调用类成员变量呢?

————————&&&——————-2016.3.23早