蓝旭预习博客：Java语法与面向对象三大特性

输入输出

输入

1.输入（键盘录入）操作需要有导包，写在类定义的上面：

import java.util.Scanner

2.创建对象，表示开始使用Scanner这个类：

Scanner sc = new Scanner(System.in);

其中sc为自定义的变量可替换为任意标识符，其余为固定格式；

3.接收数据：

int i = sc.nextInt();

其中i为变量名可替换；

输出 

输出语句一般有三种：

1.System.out.println();
换行输出，输出后会自动换行：

//示例
System.out.println("Hello");
System.out.println("World");

//输出
Hello
World

2.System.out.print();
不换行输出：

//示例
System.out.print("Hello");
System.out.print("World");

//输出
HelloWorld

3.System.out.printf();类似C语言的printf()输出语句
按格式输出：

//示例1
int m = 1;
System.out.printf("%d",m);

//输出
1

数组

介绍

数组是一种线性数据结构，可作为一种的集合容器使用连续的内存空间存放相同的数据类型。

定义与初始化

定义有如下两种格式，后者与C语言相似：

//数据类型【】 数组名；
int[] arr;

//数据类型 数组名【】；
int arr[];

 初始化则分为静态初始化与动态初始化： 

//静态初始化：
//数据类型【】 数组名 = new 数据类型{元素1，元素2，...}；
//数据类型【】 数组名 ={元素1，元素2，...}；
int[] arr = new int{1,2,...};
int[] arr ={1,2,...};


//动态初始化：
//数据类型【】 数组名 = new 数据类型【数组长度】；
int[] arr = new int[3];

静态初始化后数组存的就是大括号里的元素，而动态初始化则存的是默认值：

整数类型：0；小数类型：0.0；字符类型：'/u0000'空格；布尔类型：false；引用数据类型：null

数组访问与遍历 

访问单个数组元素格式为：数组名【索引】；索引即为角标或下标；

int[] arr ={1,2,3};

System.out.println(arr[1]);//2;

遍历为获取数组中全部元素（不一定要打印），可使用循环完成：

int[] arr ={1,2,3,4,5};

for(int i = 0; i < 5; i++){
    System.out.println(arr[i]);
}

其中对于不方便获取长度的数组，可使用"数组名.length"获取，即

int[] arr ={1,2,3,4,5};

for(int i = 0; i < arr.length; i++){
    System.out.println(arr[i]);
}

另外，在IDEA环境下，可使用"数组名.fori"直接实现遍历操作； 

流程控制语句

顺序结构

例如"Helloworld"程序，过于基础故略过；

分支结构

主要为判断与选择语句：

1.if单分支语句：

if (boolean 表达式){

​         分支内容;

​}

当只有一行分支内容 可以没有大括号，if分支只对第一行语句有效。当 if分支结束后 会继续向下执行；

2.if多分支语句：

if (boolean 表达式){

        ​ 分支内容;

​ }else if{

​         分支内容;

​ }……

当有多个条件需要判断的时候使用，只要满足一个分支以后，满足的这个分支的后面的分支就不再继续判断执行了，可提高效率；

3.三目运算符：

语法：<条件表达式>？<表达式1>：<表达式2>；

执行过程：若条件表达式的值为true，则执行表达式1，并返回相应值；否则执行表达式2，并返回相应值；可以替换简单 if else 结构；

int x,y,z;

x = 6,y = 2;

z = x>y ? x-y : x+y;//z=4;

4.switch语句：

switch (常量表达式) {

        ​ case 表达式 1 ：

        ​ 语句 1 ;

​         break;

​         case 表达式 2 ：

        ​ 语句 2 ;

        ​ break;

        ​ … …

        ​ default :（默认）

}

常量表达式必须与case内表达式数据类型相同；

循环结构

1.while循环结构： 

while(布尔表达式){

        循环体;

}

例如：

public class Task1 {	
    public static void main(String[] args) {		
        int i = 1,sum = 0;		
        while(i<=100){			
            sum+=i;			
            i++;		
        }		
        System.out.println("1+2+3+...+100的和是"+sum);	
    }
}

2.do-while循环结构：

do{

        循环体;

}while(布尔表达式);

do-while语句执行时最少执行一次，因为先执行循环体，再判断表达式;

例如：

public class Task2 {	
    public static void main(String[] args) {		
        int i = 1,sum = 0;		
        do{			
            sum+=i;			
            i++;		
        }while(i<=100);		
        System.out.println("1+2+3+...+100的和是"+sum);	
    }
}

3.for循环结构：

for(表达式1; 表达式2; 表达式3){

        循环体;

}

表达式1的作用是给循环变量初始化，表达式2的作用是给出循环条件，表达式3的作用是改变循环变量的值；

for循环的执行过程是：执行表达式1，计算表达式2，如果表达式2的值为true，执行循环体，执行表达式3，改变循环变量的值，再计算表达式2的值，如果是true，再进入循环体，形成循环，直到表达式2的值为false，结束循环，执行for后面的语句；

例如：

public class Task3 {	
    public static void main(String[] args) {		
        int sum = 0;		
        for (int i = 0; i < 101 ; i++) {			
            sum += i;		
        }		
        System.out.println("1+2+3+...+100的和是"+sum);	
    }
}

 循环控制语句

1.break：

跳出当前循环，执行循环后面的语句；

2.continue：

跳出此次循环，进入本循环结构的下一次循环；

面向对象的三大特性

（这部分内容未完全预习明白qwq，以下内容中部分摘自其他博客）

封装

对抽象的事物抽象化成一个对象，并对其对象的属性私有化，同时提供一些能被外界访问属性的方法；

封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性；

我的理解：主要指的是将数据（属性）和行为（方法）包装起来，并只允许通过预定义的方法（公共方法）来访问这些数据，从而隐藏了数据的实现细节和复杂性，感觉能使代码更简洁更易读；

继承

子类扩展新的数据域或功能，并复用父类的属性与功能，单继承，多实现；

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。
这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。比如可以先定义一个类叫车，车有以下属性：车体大小，颜色，方向盘，轮胎，而又由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱；

重写：同一个方法名称，子类继承父类的方法，根据操作的子类不同，所完成的功能也不同。

我的理解：后面的比喻较为形象，在我看来每一次对类的编程并非孤立，而是可以用做另一次编程的一部分，相当于所谓"继承"；

多态

通过继承（多个⼦类对同⼀⽅法的重写）、也可以通过接⼝（实现接⼝并覆盖接⼝）

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作
多态存在的三个必要条件
1.继承或实现：在多态中必须存在有继承或实现关系的子类和父类
2.方法的重写：子类对父类中的某些方法进行重新定义（重写，使用@Override注解进行重写）
3.基类引用指向派生类对象，即父类引用指向子类对象，父类类型：指子类对象继承的父类类型，或实现的父接口类型；

我的理解：上面的描述唯一看明白的就是 "多态是同一个行为具有多个不同表现形式或形态的能力"，简单来说多态的特性之一就是一个东西多种作用吧，但似乎这只是"多态"所代表的含义中最小的一部分？