2024蓝旭春季培训预习（一）—— JAVA语法+面向对象三大特征

 JAVA语法+面向对象三大特征

 JAVA语法

输入输出

输出

由于JAVA是一门面向对象的语言，所以所有东西都是基于已有的类来创建所需要的变量，输入输出也不例外所以我们直接看代码。

输出代码如下：

System.out.print("Hello world!!!!!");
System.out.println("Hello world!!!!!");
System.out.printf("%d %f %s",a,b,c);

代码运行结果：

Hello world!!!!!Hello world!!!!!
23 3.233 dafdf

print和println的区别就是，前者直接输出字符串，后者输出完字符串后会再加一个换行。

printf就是按照给定的方式输出。

输入

我们要像调用类型一样，进行调用已有库中的Scanner类，就像是实例变量一样进行赋值操作，给予我们创建的类型一定的空间。

        int a;
        double b;
        String c;
        Scanner reader=new Scanner(System.in);
        a=reader.nextInt();
        b=reader.nextDouble();
        c=reader.nextLine();

需要注意的是JAVA的Scanner是不能直接输入char类型的，但是我们可以先读入nextLine来读入整行，存储进String类型中，再用char进行charAt来进行访问字符串相应位置的字符。

数组

数组的声明基本和C/C++相同，主要的不同就是，JAVA不允许在定义时规定数组元素个数。我们可以通过一下的实例来进行了解。

float boy[];
char cat[][];

int [] a,b;

int a[],b[];

int [] a,b[];

最后一种需要注意，我们现在是定义了一个一维数组a和一个二维数组b。

但是上面的代码只是数组的声明，而非数组的建立。如果我们要进一步建立一个数组的话，我们需要给他开辟相应的空间。就像这样：

int a[];
a=new int[3];
a[0]=0;
a[1]=1;
a[2]=2;

就是用new来相应的开辟这段区间。

当然我们也可以将声明和开辟一起写，就像这样：

int a[]=new int[10];

二维数组也是同理的。

还有对应的length方法，对于一维数组我们返回其元素个数，对于二维我们就输出其含有一维数组的个数。

初始化时我们和c/c++也相同，二维数组可以声明长度不一的数组。

分支

众所周知，在编程语言中，分支语句一直是非常常用有非常重要的，但是各个语言的分支结构又不尽相同，因此JAVA的分支结构就与c/c++几乎完全一样，因此我们直接展示样例，不做过多的解释了。

if-else if-else语句

if(a==0)
{
    System.out.println(a);
}
else if(a>0)
{
    System.out.println("a为正数");
}
else
{
    System.out.println("a为负数");
}

switch语句

switch(c){
    case('A'):System.out.println("优秀");break;
    case('B'):System.out.println("良好");break;
    case('C'):System.out.println("及格");break;
    drfault:System.out.println("不及格");break;
}

值得注意的是switch语句不遇到break，switch将不会截止，而是继续执行接下来的为满足的条件。

循环

循环的方式也和其他语言及其类似，因而直接出示代码。

for循环

for(i=0;i<n;i++)
{
    System.out.println(i);
}

主要就是for中的第一条语句是初始化的语句，之后的是循环判断语句，最后一条时，执行完内部代码后的执行语句，也是一般情况下退出循环的关键。

while循环

a=10;
while(a==0)
{
    a--;
}

while循环没什么好讲的，while内部如果为假时就退出循环。

面向对象三大特征

封装（私有等级）

首先，我们得先知道封装是什么意思。顾名思义，封装就是将一个洞封起来不让别人看见。

可是如果将一个东西封起来，就说明除了将其起来的那个人，其他人都不知道他内部是一个什么样子的结构，这样我们所封装好的东西就是一个不透明的小黑盒。虽然外人不知道这里面是一个什么样子的构造，但是我们可以通过作者提供的一些手段来应用这个东西。

这样的好处首先就是提供了代码的安全性，使外界对里面的东西访问受限，这样就保证了内部的一些重要的必要数据不被修改；并且也大大提高了代码的复用性，可以使各种各样的东西进行应用；通过封装，带来的高内聚和低耦合，使用不同对象、不同模块之间能更好的协同，同时便于修改，增强代码的可维护性。

这在Java中主要是通过类向外界提供set和get的方式了获取内部相应的数据，这样就不会暴露内部的一些限制条件。

class car{
    int weight;

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
}

像是这样，我就封装了一个汽车类型，并且用get和set方法来限制了他人直接对于数据的访问。

继承（父子类，重写）

我们都知道Java是一门面向对象的程序，我们将所有的东西都归为不同的类里面，因此，我们看了眼通过不同的类来获得我们所想要的东西。

然而如果一个类和另一个类的关系很大，那么我们就可以将这两个类的共同点定义成一个类这就是 父类，而那两个就成了他的子类。

我们可以通过继承的方式来将父类的节点进行一个导入，使得子类也可以运用分类的变量和方法，但是这并不完全是这样的。

extends

class car{
    int weight;

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public car() {
    }

}
class benChi extends car{
    int price;

    public int getPrice() {
        return price;
    }

    public benChi(int price) {
        this.price = price;
    }
}

在Java继承可以使用 extends 关键字来实现，其中Java规定了java.lang.Object 类作为所有的类直接或间接的父类（当类没有继承其他类时，java默认继承Object类，当类继承了其他类时，可以向上追溯，最终继承的类就是Object类）。

当然，我们还需要注意

• 子类无法继承 private 修饰的属性和方法
• 子类和父类在同一包下，可以继承 default 权限的属性方法
• 子类可以对父类进行扩展，拥有自己的属性和方法
• 子类可以重写父类的方法（前提是可以继承到这个方法）（多态的体现）

super

import java.util.Scanner;

class car{
    int weight;

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
    public car(int weight) {
        this.weight = weight;
    }
}
class benChi extends car{
    int price;

    public int getPrice() {
        return price;
    }

    public benChi(int price,int weight) {
        super(weight);
        this.price = price;
    }
}

加入父类有自己的有参构造方法的话，我们的子类在构造方法的时候就必须也要对父类进行相应的构造方式，所以我们运用到了super()。从上面的我们可以看出我们通过以上的方式对于上式如此进行了一次构造。

但是如果父类是无参的构造方式，就可以不需要用到super()。如果有用到super的话，super要放在第一行。

多态

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定。所以程序就需要应对不同情况来处理赋予不同的类。

向上转换

实现多态的条件之一就是，必须要有向上转换的能力。那么什么叫做向上转换呢？其实非常的简单，当我们不知道某一个东西的时候，但是我们知道这个东西是包含在哪一个父类里面时，我们就可以用父类来声明这一个变量，然后再用相应的子类来为其开辟内存，就像下面这样：

Car bigG = new benChi();

重写

这就是我之前所说的那样，这样我们就可以应用父类和子类定义的同名的变量和方法了，但是假如父类没有定义，子类定义了的话，相应的子类也将无法使用他们独有的变量和方法。

这种父类和子类同名同参的方法其实就属于一种重写。

重载

 对于面向对象而已，多态分为编译时多态和运行时多态。其中编辑时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的函数，通过编辑之后会变成两个不同的函数，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。

实际这种就是同名但是方法中的参数类型或个数不同，实现了静态的多态，其实就是重载。

String a_toString(int a)
{
    return a.toString();
}
String a_toString(float a)
{
    return a.toString();
}

接口

首先，我们可以将接口视为一种类型，我们用interface来对相应的类进行声明，我们可以将接口视为是一种功能的集合。

接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。

接口就是通过interface 接口名{} 来进行构建的。

接口可以使类型直接来使用接口中对应的功能，通过 class 类 implements接口 {重写接口中方法} 的样子进行重写，且必须对其进行重写。

接口可以使类不再局限于单继承的模式，而是可以一次进行多个继承的插入，使得程序更加的方便和多样。因为多接口并不会产生不确定性的调用，而是必须要实现相应的方法才行。

接口中的变量以public static final来定义，保持了他的值不可改变，方法以public abstract这种方式来定义。这样可以保持它的抽象性，使得类可以自我选择具体实现形式。