java学习入门_r如何学习java-CSDN博客

java是一门面向对象的编程语言。怎样体现这个面向对象呢？举个例子：c语言在编写的过程中，你会思考如何一步步来解决问题，重点在编写的过程当中；面向对象则有些细微差别，是通过直接作用在对象实体上面的操作。对还没有接触面向对象编程同学这么说可能有点抽象。但不要关键，在接下来的学习中你会慢慢就理解了面向对象这个意思了。

变量与语法

这些内容与C,C++,亦或是其他语言没有什么不同，只是在细节上有些微差别。即使是对于没有编程经验的同学，也可以通过抄写代码来理解这部分内容。所以这里就简单提个常用的语句，方便学习和理解，在理解这些语句后相信对其他的语法也能够有一个很好的认识。

下面是一个简单的for循环语句，给数组a赋值，对于数组的初始化参考菜鸟教程对数组的说明，运行的结果就是a[0]到a[9]依次赋值为0到9。

public class Main {
    public static void main(String[] args) {
        int n=10;
        int a[]=new int[10];
        for (int i=0;i<n;i++){
            a[i]=i;
        }
    }
}

代码中有一个Main类（public class Main{}，对于类的介绍下面会介绍），类中有一个public static viod main(){}，这里类似于C语言中的int main(){}，要有这个部分，代码才能运行。在main函数中，你所写的语句才能够被运行，不在main函数中的语句在被调用时才会运行。

类，接口，继承与包

类(class)

讲解到这个部分时，Java面向对象的编程就体现出来了。我们平时生活中到经常会说a和b是同一类人，这里我们使用了归类，而在这编程当中，我们往往会遇到具有相同行为的变量，此时我们就把它归到同一类了。而这个类当中的一个个体就是一个对象。

例如下例中的圆类，circle_1和circle_2就是两个对象，他们具有相同的属性（半径，面积，周长）和行为（周长计算，面积计算，方法实体未写出）。

package com.asouwn;

public class circle {
    private double R;//半径
    private double S;//面积
    private double L;//周长
    public circle(double R){
        this.R=R;
    }
    public void getS(){}
    public void getL(){}
}

import com.asouwn.circle;

public class Main {
    public static void main(String[] args) {
        circle circle_1=new circle(2.5);
        circle circle_2=new circle(3.0);
    }
}

接口(interface)

编写接口的方式和类很相似，接口和类在层次上属于同一级。区别在于，接口中是抽象方法，也没有构造器，也就不能创造对象，接口不能包含成员变量，除了 static 和 final 变量。

interface Animal {
   public void eat();
   public void travel();
}
public interface Animal_1 {
    public void O();
}

接口的实现(implements)

public class dog implements Animal,Animal_1{
    @Override
    public void eat() {
        System.out.println("eat");
    }
    @Override
    public void travel() {
        System.out.println("travel");
    }

    @Override
    public void O() {
        System.out.println("zero");
    }
}

接口就是子类的义父，或者说干爹，可以有多个，且是被发现(implements) 。因为接口没有方法实体，他只有抽象内方法，所以在被发现后，类要通过重写(override)的方式实现方法。重写后方会提到。

继承(extends)

继承是通过extends语句来实现的。首先有类的继承当一个类与另一个类有相同的行为和属性，或是说就像是另一个类的后代一样，继承了父类的属性和行为。同样要注意，就像一个人只能有一个父亲，一个类也只能继承一个父类。

下例，dog类就继承了父类animal的属性和行为，而dog类继承了父类animal类后，就不能再继承另一个类了。

public class animal {
    private String name;
    private int id;
    public animal(String name, int id) {
        this.name = name;
        this.id = id;
    }
    public void eat(){
        System.out.println(name+"正在吃");
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() {
        System.out.println("大家好！我是"+ id + "号" + name + ".");
    }
}

public class dog extends animal{
    public dog(String name, int id) {
        super(name, id);
    }
}

而与类不同，接口是可以多继承的。这里接口Animal_2继承了Animal和Animal_1。而two()方法是他自己的抽象方法。

public interface Animal_2 extends Animal,Animal_1{
    public void two();
}

包(package)

在我们的相册当中，或是文件管理上面，我们往往会把相关度高，内容方向相同的文件放在同一个文件夹当中。在编程过程中，我们为了提高效率，可读性和便捷性，也会把相关度高的代码和接口收纳在同一个包中一般在文件头加上package packagename;

如下例，包名为com.asouwn。

package com.asouwn;

public class circle {
    private double R;//半径
    private double S;//面积
    private double L;//周长
    public circle(double R){
        this.R=R;
    }
    public void getS(){}
    public void getL(){}
}

而在其他包中引用这个包的内容时，需要import 包名.类名；如果要引用这个包里的所有类，则为import 包名.*。这里*号是通配符，详情可了解正则表达式。

import com.asouwn.circle;

public class Main {
    public static void main(String[] args) {
        circle circle_1=new circle(2.5);
        circle circle_2=new circle(3.0);
    }
}

import com.asouwn.*;

public class Main {
    public static void main(String[] args) {
        circle circle_1=new circle(2.5);
        circle circle_2=new circle(3.0);
    }
}

重载，重写与多态

在这一部分，你可以明显体会面向对象的概念。

重载(overload)

生活中，对于加减法，我们有整数间的加减法，小数间的加减法，等等。如果把加减法抽象成函数方法，那么它面临int型的变量，也有double型的变量等等。而它们的方法名都是加减法。这时，面向对象的编程语言提供了一种重载的概念，同一变量名，面对不同型的参数会调用不同的方法。

public class plus {
    public void P(int a,int b){
        int c=a+b;
    }
    public void P(double a,double b){
        double c=a+b;
    }
}

重写(override)

重写是在类与类之间继承体现的。前文提到子类会继承父类的属性和行为，生活当中，比如车，不同的车都有Trial（移动）这个行为，但具体的实现方法不同，比如自行车是靠双腿蹬，油车是靠汽缸推动。子类继承父类的方法后会根据实际需要重写为自己需要的方法。

public class a extends plus {
    @Override
    public void P(int a, int b) {
        System.out.println(a+"and"+b);
    }
}

这里类a继承了plus的方法，但是根据a的需要，方法P不再是计算a+b了，而是打印出 aandb。但是注意，重写并不能改变方法名和传参。

多态

现实生活中，我们往往会在不同环境下用同一个动作输出不同的结果。比如动作拍。比如拍苍蝇和与伙伴拍掌，如果输出相同的结果，我们可以一巴掌拍死苍蝇，那么也就一巴掌拍死了伙伴。

而多态的实现方法有三：

通过重写实现
通过接口实现。因为接口并没有方法实体，需要重写的方式填充方法实体。
通过抽象类实现。这里不详细说明，可以在菜鸟相关说明处看。笔者也会在之后的文章说明。

实现封装

前面我们了解到了重写。而我们在实际运用当中，往往不希望个别内容显示出来。举个例子，我们在一个方法类当中写了个过渡方法，这个过渡方法是不希望外部调用的，或是一些类当中的数据不希望被外部直接访问修改，这时我们将他封装起来。

封闭步骤也很简单：

设置public和private内容
对一些private内容设置公共的访问方法

如下例，R是private内容，不能被直接访问，而我要访问R的数值只有通过我的public double getR()来访问。

public class circle {
    private double R;//半径
    private double S;//面积
    private double L;//周长
    public circle(double R){
        this.R=R;
    }
    public double getR(){
        return R;
    }
}

输入与输出

这里介绍一些简单和常用的输入与输出语句。

System.out.println();//输出并在最后打印一个换行符
Scanner scanner=new Scanner(System.in);//从键盘录入，回车结束。将录入值记录在scanner中。

后面笔者会出文章介绍流式输入输出，还有文件上的读写操作。