目录
前言
这篇文章主要学习了Java的基本语法以及其面向对象的三大特性。主要内容为Java的输入输出、数组、分支、循环；面向对象：封装（私有等级）、继承（父子类、重写）、多态（接口、重载）。
一、Java的基本语法
1.1输入与输出
读取输入：需要先进行导入Scanner类（在java.util包中），即import java.util.Scanner;
接着利用Scanner类声明输入对象
- Scanner reader = new Scanner(System.in);
然后我们利用reader可以进行以下输入操作：
import java.util.Scanner;
import java.lang.String;
public class Test{
public static void main(String args []){
Scanner reader = new Scanner(System.in);
//读取一个Int型数据
int x;
x = reader.nextInt();
//读取一个Double型数据
double y;
y = reader.nextDouble();
//读取一整行，以Enter键为结束符
String str = new String ();
str = reader.nextLine();
//读取一个单词，以空白符（Tab、Enter、空格）为结束符
String str2 = new String ();
str2 = reader.next();
reader.close();
}
}输出：一般常用的有三种方式：换行输出、不换行输出、格式化输出。
public class Test{
public static void main(String args []){
//换行输出
System.out.println("Hello World!");
//不换行输出
System.out.print("Hello My Friends");
//格式化输出
int x = 2;
int y = 3;
System.out.printf("%d + %d = %d",x,y,x+y);
}
}1.2数组
- 数组声明（特别注意，Java声明时不可以直接在数组后[ ]内指定元素的个数）
public class Test{
public static void main(String args []){
//声明一维数组
int a [];//等价于int [] a;
//声明二维数组
int [][] b;//等价于int b [][];
//此外还可以一次性声明多个数组
int [] x, y [];//这里x是个一维数组，y是个二维数组
int z [], k []; //这里z和k都是一维数组
}
}- 为数组分配元素
public class Test{
public static void main(String args []){
int num [];//声明数组
num = new int[10];//new可以理解为用来申请空间
//在实际操作中，数组的声明和分配元素可以放到一起
int stunum [] = new int[20];
//而对于二维数组
//第一种是一次性分配完行和列
int a[][] = new int[20][20];
//第二种可以先分配行，再分配列
//这表明在Java中二维数组中一维数组的长度可以不相同
int b[][] = new int[3][];
b[0] = new int[10];
b[1] = new int [90];
b[2] = new int[70];
//此外，在Java中也允许Int型变量来当指定数组的元素个数
int NUM = 100;
int ans [] = new int[NUM];
}
}- 数组的初始化（在Java中数字型数组的默认初始值为0，逻辑型数组的默认初始值为false）
public class Test{
public static void main(String args []){
//第一种是在声明的时候赋初值
int num [] = {1,2,3};
//第二种是一个一个赋初值
int ans [] = new int[3];
ans[0] = 1;
ans[1] = 9;
ans[2] = 10;
}
}- 数组的常用操作
除了length之外，在Java的java.util包中有Arrays类，利用import导入Arrays类即可使用 ：Arrays.sort()、Arrays.fill()、Arrays.equals()等操作。
import java.util.Arrays;
public class Test{
public static void main(String args []){
int num [] = {4,1,7,18,9,78,132,2,6};
int x [] = {1,2,3};
int y [] = {2,1,3};
//获取数组的长度 数组名.length
System.out.println(num.length);
//对数组排序
//其中可以有指定起点和终点进行排序
Arrays.sort(num);
Arrays.sort(num,1,5);
//对数组赋值
//前边是操作的数值，后边是对整个数组要赋的值
Arrays.fill(num,7);
//比较a，b数组是否完全一致，包括位置信息
//是返回true，反之false
Arrays.equals(x,y);
System.out.println(Arrays.equals(x,y));
}
}1.3分支与循环
格式与C语言中的格式大差无几。
public class Test{
public static void main(String args []){
//单分支语句
if(/* 条件 */){
//若干语句；
}
//双分支语句
if(/* 条件 */){
//若干语句；
}
else{
//若干语句；
}
//多分支语句
if(/* 条件 */){
//若干语句；
}
else if (/* 条件 */){
//若干语句；
}
else{
//若干语句；
//多选择分支语句
switch(x){
case 0:
System.out.println("0");
break;
case 1:
System.out.println("1");
break;
//…………
}
}
}
}循环也类似。
public class Test{
public static void main(String args []){
while(/* 表达式 */){
//若干语句
}
do{
//若干语句
}while(/* 表达式 */);
for(/* 表达式1 */;/* 表达式2 */;/* 表达式3 */){
//若干语句
}
}
}此外，由于数组遍历的常用，在Java中实现了加强的for语句用于遍历数组。
public class Test{
public static void main(String args []){
int num [] = {4,1,7,18,9,78,132,2,6};
int sum = 0;
for(int i : num){//声明变量：数组名
sum += i;
}
System.out.println(sum);
}
}二、面向对象
2.1封装
-
什么是封装
封装就是将数据和对数据的操作（方法）包装在一起，并隐藏其信息与内部实现细节起来，仅对外提供公共访问方式的方法。形象地理解，就是把我们原本一些公共通用的逻辑实现装入到一个盒子（class）里，并在这个盒子上标明出入口。于是，在我们需要用到已经被我们封装好的逻辑实现时，我们直接连接上它的出入口使用即可，当不用的时候直接丢弃。这样一来提高了代码的模块化程度，增强了代码的复用性，提高了代码安全性和维护性。
-
封装的实现
- 私有属性：在Java中，可以使用private关键字将类的属性（即成员变量）设为私有，这样其他类就不能直接访问该属性。
- 公共方法：为了提供对私有属性的访问，类会提供公共的get和set方法。getter方法用于获取属性的值，setter方法用于设置属性的值。
例如下图：将Squares封装为类，其具有长x和宽y，将x、y的set和squares的get封装起来。我们在求解问题时就直接使用，而不必担心其内部是如何实现的。
class Squares {
int x;
int y;
public void setx(int x){
this.x = x;
}
public void sety(int y){
this.y = y;
}
public int getsquares() {
return x*y;
}
}-
私有等级
封装的级别包括四个（按权限从高到低排序）：public（公开的）、protected（受保护的）、default（默认为友好的）、private（私有的）。
其中：
| public | 这是访问权限最宽的修饰符。被声明为public的成员可以被任何类访问，无论它们是否在同一包中。 |
| protected | 被声明为protected的成员可以被同一个包中的其他类访问，也可以被不同包中的子类访问。 |
| default | 如果一个成员没有使用任何访问修饰符，那么它只能被同一个包（package）中的其他类访问。 |
| private | 这是访问权限最严格的修饰符。被声明为private的成员（包括变量、方法、构造器和内部类）只能在其所在的类中被访问。 |
2.2继承
-
什么是继承
继承可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。就是指在原有类的基础上，进行功能扩展，创建新的类型。换句话说，我们把一些类的共同特点提炼出来，把他可以当做父类，而这些类就是他的子类。继承关系的两个类，一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
-
继承的特点
Java中类只有单继承，没有多继承。即一个子类最多只能有一个父类。子类可以有父类的内容，子类还可以有自己特有的内容。Java规定java.lang.Object 类作为所有的类直接或间接的父类。注意子类无法继承 private 修饰的属性和方法。
-
重写（override）
定义：
在子类中创建了一个与父类中名称相同、返回值类型相同、参数列表的方法相同，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写（override）。
注意：
- 构造方法不能被重写。
- 声明为 final 的方法不能被重写。
- 如果不能继承一个方法，则不能重写这个方法。重写是在继承的基础上，如果方法无法被继承那么就无法重写。
例如：
class animals{//父类
int numbers;//子类可以继承父类的成员变量
String name;
public void eat() {//父类方法
System.out.println("有食肉动物、食草动物、杂食动物");
}
}
class cat extends animals {//子类继承
String color;
public void setName(String x){
name = x;//cat继承了animals的name
}
public void eat(){//对父类的方法进行重写
System.out.println("爱吃鱼");
}
}当子类继承父类的方法和变量时，若所声明的变量或方法与父类相同时，子类会隐藏父类的成员变量和方法。但当我们又想使用父类的变量或方法时，我们可以使用super()来操作。
例如：
class Sum{
int n;
int fun(){
int sum = 0;
for(int i=1;i <= n; i++){
sum+=i;
}
return sum;
}
}
class Ave extends Sum{//Sum的子类
int n;
int fun(){//方法重写
int c;
super.n=n;//使用隐藏的父类变量与方法
c=super.fun();
return c;
}
}
public class test{
public void main(String[] args) {
Ave ave = new Ave();
ave.n=10;
System.out.println(ave.fun());
}
}2.3多态
-
什么是多态
多态是指同一种行为具有多个不同的表现形式或形态的能力。在父类中定义的属性和方法被子类继承后，可以有不同的数据类型或表现出不同的行为。简单说就是儿子可以和父亲不一样。
-
多态的实现
必要条件：
- 继承：在多态中必须存在有继承关系的子类和父类。
- 重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
- 向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。
animals niko = new cat();//向上转型实现方式：
方法重载和方法重写。方法重载是指在同一个类中定义的方法可以同名，但其参数列表必须参数个数不同或参数类型不同；方法重写则是指在不同的类中定义相同的方法。
例如：方法重写在上面的例子中已经被提到
方法重载：
//方法重载
class Calculator {
int x;
int y;
int add(int x, int y){//同一方法名，不同参数列表或返回类型，重载
return x+y;
}
double add(double a,int y){
return a-y;
}
}-
接口
接口是用来完成某一特定功能的没有方法体的方法（抽象方法）和常量的集合。使用关键词interface来定义一个接口。简单说就是功能的定义和它的实现分离开来，加强了模块化程序设计。
1.声明
interface Example {
public static final int MAX = 100;//常量
public abstract void add(int n);//没有方法的方法（抽象方法）
public abstract int SUM(int x,int y);
}2.实现接口
使用implements，实现接口后必须重写接口中的方法，且可以使用接口中的常量
例如：
class Member implements Example {
public int add(int n){
int sum=0;
for(int i=1;i<=n;i++){
sum+=i;
}
return sum;
}
public int SUM(int x,int y){
return x+y+MAX;
}
}3.接口回调
用接口声明的变量成为接口变量，接口回调就是指将已经接口实现的类创建的对象的引用赋给接口变量。类似于向上转型。
例如：
public class test{
public void main(String[] args) {
Example ex = new Member();//接口回调
ex.showMe("Hello");
}
}
interface Example {
public abstract void showMe(String x);
}
class Member implements Example {
public void showMe(String x){
System.out.println(x);
}
}学习笔记 如有错误 日后修改(∗ᵒ̶̶̷̀ω˂̶́∗)੭₎₎̊₊♡
150
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
