Java类、方法与接口

我会带着你远行 2022-08-19 13:15 161阅读 0赞

*  类与方法的声明
    
     *  类的组成
     *  方法的组成
     *  类与方法的小例子
     *  如何声明一个对象并调用方法
        
         *  实参与形参的区别形参在声明方法时使用用来存放实参实参在调用方法使用将数据赋给形参的意思为调用
     *  构造方法
     *  方法重载
     *  方法的继承
        
         *   *  继承中有一个比较重要的默认执行过程
     *  this和super
     *  最终类final和抽象类abstract
     *  方法的多态
     *  接口
        
         *  声明和实现接口注意关键字interface和implements
         *  使用接口

--------------------

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()方法并传递两个参数（实参），然后将返回值赋给b
    a.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();
        }
    }

--------------------