新手预习，可能有不少错误。
目录
一、基础语法：
1.输入输出
2.数组
3.分支
4.循环
二、 面向对象的三大特性：
1.封装（私有等级）
2.继承（父子类，重写）
3.多态（接口，重载）
一、：
1.输入输出：
输出：
1、println（），多个类型之间用 ‘+’ 连接，行末自动换行。单独使用当做换行符。
2、print（），必须有参数，行末不自动换行。
3、printf（），与c语言类似。
输入：
分为4个步骤：
1、导入相关的包：import java.util.Scanner;
2、创建Scanner类型的对象：Scanner scanner= new Scanner( System.in) ;
3、调用Scanner类的相关方法(next() / nextXxx()) ，Xxx为指定的变量类型（Int，Double等）；
4、释放资源：调用Scanner对象的close()方法， scanner.close();
一些问题：
1.遇到需要读入字符串时，如果该程序前面读入了整型等数据类型，会用回车作为输入的终止条件，此时因为字符串读入的终止条件为回车，就会跳过输入字符串，可以通过使用scanner.nextLine()吃掉这个换行符。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
int sum = 0, cnt = 0;
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
scanner.nextLine();
String s = scanner.nextLine();
System.out.println(num + " " + s);
scanner.close();
}
}
2.需要循环输入时可以用scanner.hasNextXxx来判断是否还有Xxx类型数据输入，若接下来的数据不是Xxx类型的则返回False终止循环（字符串需要输入特殊字符终止）。
2.数组：
初始化：分为动态初始化和静态初始化；
动态初始化：
int a[] = new int[3]; // 1
int []a = new int[3]; // 2
int a[];
a = new int[3]; // 3静态初始化：
int a[] = new int[]{1,2,3,4,5};
// 拆分
int a[];
a = new int[]{1,2,3,4,5};
//格式可省略
int a[] = {1,2,3,4,5};可用 Arrays.fill()来快速初始化一维数组（使用时记得导入对应头文件 java.util.Arrays）；
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int a[] = {1,2,3,4,5};
Arrays.fill(a,1);
for (int i = 0; i < 5; i++)
System.out.print(a[i]);
}
}
//结果为11111访问：与c语言类似，数组最大索引值为数组名.length - 1; 最小索引值为0；
// 访问数组元素：数组名[索引值]；
二维数组：
初始化：
int[][] a1 = new int[4][4];
int a2[][] = new int[4][4];
int a3[][] = {{ 1, 1, 1 }, { 2, 2, 2 }};
int a4[][] = new int[][] {{ 1, 1, 1 }, { 2, 2, 2 }};
二维数组的每一维的长度不一定要相同：
int[][] a = new int[3][];
a[0] = new int[1];
a[1] = new int[2];
a[2] = new int[3];
// a[0].length,a[1].length,a[2].length的长度分别为1,2,3；
获取二维数组的长度：
a.length为a第一维的长度，a[0].length为a第一维第一个数组的长度;
int[][] a = new int[4][];
a[0] = new int[1];
a[1] = new int[2];
a[2] = new int[3];
a[3] = new int[1];
// a[0].length,a[1].length,a[2].length的值分别为1,2,3;
// a.length的值为4;3.分支：
1.if - else语句：
if( 布尔表达式 ){
//当布尔表达式为true时执行
}else{
//当布尔表达式为false时执行
}
基本与c语言一致，值得注意的是与c语言不同的是括号里只能是布尔型数据，若不是则会报错。
2.Switch语句：
switch(表达式) {
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
...
default:
语句体n+1;
}
在该程序中，若不写break则程序会在第一个满足的case开始一直向下走，直到遇到break或switch语句结束。其中，default语句中的内容是前面没有满足的case时执行的，default语句可以没有。
4.循环：
1.while 语句
2.for 语句
3.do ... while 语句
循环的语句与c语言类似，但要注意java中判断循环终止条件的语句必须是布尔型的；
同时，遇到在一个范围内做循环时，优先使用for循环； 当循环的次数不确定时优先使用while循环；
二、
1. 封装：
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互.
封装的作用
1.提高了程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 增强系统的可维护性
即用private等访问修饰限定符使得在外部类中无法直接访问一个对象的实际数据，而需要通过对象所处的类中的方法来访问，这是信息隐藏。
注意到这时s.a中的‘a’ 是非法的，这是因为a是‘private’的，无法在外部被调用。
public class fengzhuang {
private int a;
}
class app {
public static void main(String [] args) {
fengzhuang s = new fengzhuang();
s.a;
}
}要想让a在能在外部被调用，并修改，就需要加两个方法来实现。
public class fengzhuang {
private int a = 10;
public int getInt() {
return this.a;
}
public void setInt(int a2) {
this.a = a2;
}
}
class app {
public static void main(String [] args) {
int b = 20;
fengzhuang s = new fengzhuang();
s.setInt(b);
int a1 = s.getInt();
System.out.print(a1);
}
}
这样就可以修改 s.a 的值并输出了；
2.继承：
继承可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法。
继承是指在原有类的基础上，进行功能扩展，创建新的类型。
格式：public class 子类名 extends 父类名 {}
class Fu {
public int a = 100;
public void say() {
System.out.println("sss");
}
}
class Zi extends Fu {}
public class App {
public static void main(String []args) {
Zi s = new Zi();
s.say();
System.out.print(s.a);
}
}
super可以在子类定义了一个a时访问父类的a； 效果与this比较相似；
public class jicheng {
public static void main(String[] args) {
Zi s = new Zi();
s.show();
}
}
class Fu {
public int a = 100;
}
class Zi extends Fu {
public int a = 50;
public void show() {
int a = 30;
System.out.println(a); // 30
// 访问本类中的成员变量age
System.out.println(this.a); // 50
// 访问Fu类中的成员变量age
System.out.println(super.a); // 100
}
}重写：在子类中重新定义父类中的方法；
【方法重写的规则】：
1.子类在重写父类的方法时，一般必须与父类方法原型一致：修饰符 返回值类型 方法名(参数列表) 要完全一致
2.JDK7以后，被重写的方法返回值类型可以不同，但是必须是具有父子关系的。
3.访问权限不能比父类中被重写的方法的访问权限更低。
4.父类被static、private final修饰的方法不能被重写。
原文链接：https://blog.csdn.net/m0_62476684/article/details/124027223
public class chongxie {
public static void main(String[] args) {
F s1 = new F();
s1.say();
Z s = new Z();
s.say();
// 输出的结果是 111
// 222
}
}
class F {
public void say() {
System.out.println("111");
}
}
class Z extends F {
public void say() {
System.out.println("222");
}
}3.多态：
多态的转型：
1.向上转型：父类的引用指向子类的对象
父类类型 引用名 = new 子类类型（）;
// 这实际上是创建一个子类的对象，并把他当做父类去使用注意这样可调用所有父类成员（需遵守访问权限），但不能调用子类特有的成员。
2.向下转型：一个已经向上转型的子类对象，将父类引用转为子类引用
子类类型 引用名 = (子类类型) 父类引用名;
//用强制类型转换的格式，将父类引用类型转为子类引用类型
代码如下：
public class chonggou {
public static void main(String []args) {
Life l1 = new People();
l1.say();
People s1 = (People) l1;
s1.Know();
//输出结果为 people 111
}
}
class Life {
public int a = 10;
public void say() {
System.out.print("life ");
}
}
class People extends Life {
public void say() {
System.out.println("people");
}
public void Know() {
System.out.println("111");
}
}注意：需要类与类之间有继承关系才能进行类型转换。
接口：
什么是接口
（1）接口关键字 interface
（2）接口实际上为一个特殊的抽象类，因此无法实例化
（3）接口中定义的属性都是静态常量
（4）其中所有方法都默认有public abstract修饰
（5）同一个类可以实现多个接口，引入时，用implements关键字，多个接口用”,”隔开
（6）类使用接口时，必须将接口中定义的方法全部重写
原文链接：https://blog.csdn.net/weixin_52071901/article/details/131084569
public class jiekou {
public static void main(String []args) {
Shu s1 = new Zrs1();
s1.out();
}
}
interface Shu {
void out();
}
class Zrs1 implements Shu{
public void out(){
System.out.println("111");
}
}重载：
重载:在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
public class chongzai {
public static void main(String []args) {
example a = new example();
a.add();
a.add(1,2);
a.add(1,2,3);
//结果为 111 3 6；
}
}
class example {
public void add() {
System.out.println("111");
}
public void add(int x,int y) {
System.out.println(x + y);
}
public void add(int x,int y,int z) {
System.out.println(x + y + z);
}
}
917
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
