Java类、方法与接口

---

java中如果没有类与对象就不能叫java了

---

类与方法的声明：

类的组成：

         [修饰符] class 类名 {           属性。。。           方法。。。          }

方法的组成：

          [修饰符] 返回值类型 方法名（[参数1][参数2]......）{方法体}

类与方法的小例子：

     public class Alei{          public void aMethod(){               //无参数，返回值类型为空               }          public void bMethod(int a){               //有一个参数（形参），返回值类型为空               }          public int cMethod(int a,int b){               //有两个参数（形参），返回值类型为int               return a+b;               //返回值为a+b               }          }

注：类的标志为类名前有class，带有public修饰符的类为主类且一个java文件中只能有一个主类。类中可以声明另一个类。方法标志为方法名后有括号。

---

如何声明一个对象并调用方法：

声明对象：
类名 变量名（存放一个对象） =new 方法名（）;
调用方法：对象.方法名()；

例如（继续使用上述类与方法的声明）：

Alei a=new Alei();a.aMethod();//调用aMethod()方法，无参数int b=a.cMethod(5,6);//调用cMethod()方法并传递两个参数（实参），然后将返回值赋给ba.cMethod(5,6);//有返回值的方法依然可以当做无返回值的方法使用

实参与形参的区别：形参在声明方法时使用，用来存放实参；实参在调用方法使用，将数据赋给形参。“.”的意思为调用。

---

构造方法：

构造方法的组成：
访问权限 类名 （）{
……
}

public void Alei{       public Alei(){        //不写任何构造方法，此方法为默认调用；但如果有其他的构造方        //法而又想用这个默认的构造方法，需要写出默认的构造方法才能        //用       }       public Alei(int a){        //自定义的构造方法       }}

注：在声明对象的时候默认调用构造方法
例如

    Alei a=new Alei(); //是调用第一个构造函数    Alei b=new Alei(5);//是调用第二个构造函数 

---

方法重载：

重载是根据方法返回值类型（void以及其他数据类型）或参数（个数以及顺序）来实现的。

public void ff(){    //普通方法}public int ff(){    //与第一个方法相比，加了返回值类型，与其他方法不相同    return 10;}public void ff(int a){    //与第一个方法相比，加了一个参数，与其他方法不相同}public void ff(int a,String b){    //与第一个方法相比，加了两个参数（注意参数的顺序），与其他方法    //不相同}public void ff(String b，int a){    //与第一个方法相比，加了两个参数（注意参数的顺序），与其他方法    //不相同}

肯定会有人怀疑两个参数类型相同怎么办，我也测试了

Public void ff(int a,int b){      //      }Public void ff(int b,int a){      //      }

会发生报错，因此这种情况排除在重载的范围之外

---

---

方法的继承：

写法（假设已经定义好两个类：Alei和Blei）

public class Alei extends Blei{......}

继承中有一个比较重要的默认执行过程：

例如：

//A类：public class A {    public A() {        System.out.println("A类无参");    }}//B类public class B extends A {     public B(String s) {        // super();这一句不写也是要默认执行，如果A类中没有无参构造方法，这里会报错         System.out.println("B类有参");    }}//C类public class C {    public static void main(String[] args) {        B b=new B("1");    }}

输出结果为
A类无参
B类有参

---

子类可以直接使用父类的方法和变量（要注意main方法是静态）
子类可以重写父类的方法
重写的重要性：java本身是由开发者按照自己的要求封装好的代码，如果想让代码按照个人的需要修改，重写就是一个很不错的选择。

---

this和super

this代表的是自己类的一个对象
super代表的是父类的一个对象
this和super在静态方法中无法使用

---

最终类（final）和抽象类(abstract)：

final和abstract的位置：如果有修饰符就跟着修饰符的后面，没有的话就放在修饰符的位置
final很简单：它修饰的类不能被继承，它修饰的方法不能被重写
abstract有点麻烦：

abstract class Ooo {    public void ff() {        //抽象类的普通方法可正常使用    }    abstract void ff2();            //抽象类的抽象方法只声明一个方法的名字}class mm {    Ooo o = new Ooo() {        @Override        public void ff() {            // 必须重写ff()才能使用，不重写不会报错        }        @Override        void ff2() {            // 必须重写ff2()才能使用，不重写会报错        }    };}

---

方法的多态：

public class test {    public void ff() {        System.out.println("我是父类");    }    public static void main(String[] args) {        test t1 = new test01();//声明了一个test01的对象        t1.ff();        test t2 = new test02();//声明了一个test02的对象        t2.ff();    }}class test01 extends test {    @Override    public void ff() {    //重写ff()        System.out.println("我是大娃");    }}class test02 extends test {    @Override    public void ff() {    //重写ff()        System.out.println("我是二娃");    }}

---

接口

声明和实现接口（注意关键字interface和implements）

interface In {    void talk();//声明一个方法的名字}class one implements In {    @Override    public void talk() {    //重写接口的方法        System.out.println("one");    }}class two implements In {    @Override    public void talk() {    //重写接口的方法        System.out.println("two");    }}

使用接口：

public class InTest {    public static void main(String[] args) {        In in1 = new one();//声明经过one类重写的接口        in1.talk();        In in2 = new two();//声明经过two类重写的接口        in2.talk();    }}

---