Java基础

一、数组

1、动态初始化

int arr = new int[3];

1. 数组名字是地址
2. 默认初始值为0
3. 数组的内存分配

2、数组的内存分配

1. arr存在栈里，只存地址，是局部变量，相当于指针
2. new出来的实体/对象存在堆里，存放数据，用完也不会立即消失
3. 数组索引是通过地址引用堆的数据

3、数组的嵌套

int[] arr1 = new int[3];
int[] arr2 = arr1;

4、静态初始化

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

5、数组长度

arr.length();

二、数据接收

import java.util.Scanner;
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();

三、面向对象基础

1、类的定义

public class 类名 {
    成员变量;
    成员方法(){
        方法；
    }
}

2、创建对象

类似于c++的结构体

类名 对象名 = new 类名();

3、封装

1）private关键字与get/set方法

1. A/t + Insert能自动填充
2. 用于保护成员变量

public class Num {
	private int num;
    public void setNum(int i){
        num = i;
    }
    public int getNum(){
        return num;
    }
}

2）this关键字

用于区分局部变量和成员变量

public class 类名 {
	private int num;
	public void setNum(int num) {
		this.num = num;
	}
	public int getNum() {
		return num;
	}
}

4、构造方法

当给出构造方法之后，系统将不再提供默认的无参构造方法

public class 类名 {
	private int num;
	private String name;
	public 类名() {}
	public 类名(int num) {
		this.num = num;
	}
	public 类名(String name) {
		this.name = name;
	}
	public show(){
		//用于显示对象信息
	}
}
类名 c1 = new 类名(123);
类名 c2 = new 类名(“wmh”);

四、字符串 String

1、构造方法

public String(...);
String str = "wmh";

2、字符串的比较

1）“==” 比较法

1. 基本数据类型：比较数值
2. 引用数据类型：比较地址

2）比较字符串：equals

//定义
public boolean quuals(Object anObj);
//使用
boolean b = str1.equals(str2);

3、字符串长度：length

//定义
public int length();
//使用
int strlen = str.length();

4、首字符查询：startsWith

//定义
boolean startsWith(Name n)

5、分离字符串：charAT

//定义
public char charAT(int index);
//使用
char c = str.charAT(2);

五、可变字符串 StringBuilder

1、构造方法

public StringBuilder();
public StirngBuilder(String s);

2、成员方法

1）SB添加数据：append

//定义
public StringBuilder append(任意类型);
//使用
sb.append("wmh");
//链式编程
sb.append("wmh").append("is").append(666);

2）SB序列反转：reverse

//定义
public StirngBuilder reverse();
//使用
sb.reverse();

3、String与StringBuilder的转化

1）String -> SB：toString

//定义
public String toString();
//使用
String str = sb.toString();

2）SB -> String：构造方法

//定义
public StringBuilder(String str);
//使用
StringBuilder sb = new StringBuilder(str);

六、集合ArrayList

1. util包
2. 类似于c++的向量vector

1、定义

1. ArrayList<范型>
2. 自带中括号

2、构造方法

//定义
public ArrayList();
//使用
ArrayList<String> array = new ArrayList<String>();

3、成员方法

1）元素追加：add

//定义
public boolean add(E e);
//使用
array.add("wmh");

2）元素插入：add

//定义
public void add(int index, E e);
//使用
array.add(0, "wmh");	//注意索引的越界访问

3）元素删除：remove

//定义
public boolean remove(Object obj);
public E remove(int index);
//使用
array.remove("wmh");
array.remove(0);

4）元素修改：set

//定义
public E set(int index, E e);
//使用
array.set(0,"wmh");		//注意索引的越界访问

5）元素获取：get

//定义
public E get(int index);
//使用
String str = array.get(0);

6）元素个数：size

//定义
public int size();
//使用
int len = array.size();

七、继承

1、继承概述

1. 定义

public class 子类名 extend 父类名{}

2. 继承的优缺点
   1. 好处：提高了代码复用性和维护性
   2. 弊端：类的耦合性增强了，容易出八嘎

2、super关键字

1. 用途：区分父类和子类
2. 使用方法
   1. 成员变量：super.成员变量
   2. 构造方法：super(...)
   3. 成员方法：super.成员方法()

3、继承中的访问顺序

1）子类方法

1. 子类局部变量i -> 子类成员变量this.i -> 父类成员变量super.i
2. 不考虑爷爷类

2）构造方法

1. 子类的所有构造方法均访问父类无参构造方法，默认为super();
2. 父类没有无参构造方法可以用super方法调用带参构造

3）成员方法

1. 子类成员方法 -> 父类成员方法
2. 不考虑爷爷类

4、方法重写

1. 定义：子类写一个和父类相同的成员方法
2. 注解：@Override --> 用于检查重写声明的正确性
3. 注意事项
   1. 私有方法不继承，不能重写
   2. 子类方法访问权限不能比父类低 --> public > 默认 > 私有
   3. 只能单继承

八、包

包的定义格式

package 包名;		//多级包用.分割

九、修饰符

1、权限修饰符

修饰符	同类	同包异类	异包子类	异包异类
Private	√
默认	√	√
Protected	√	√	√
Public	√	√	√	√

2、final关键字

1. 使用范围：成员方法、成员变量、类
2. 含义：表示不能被重写、再赋值和继承
3. 修饰局部变量的特点
   1. 基本类型：数值不变
   2. 引用类型：地址不变

3、static关键字

1. 含义：静态
2. 使用范围：成员方法、成员变量
3. 特点：
   1. 被类的所有对象共享
   2. 可以通过类名或者对象名直接调用

十、多态

1、多态的前提和体现

1. 有继承/实现关系
2. 有方法重写
3. 有父类指向子类对象

2、访问特点

成员变量：编译看左边，运行看左边

成员方法：编译看左边，运行看右边

原因：成员方法有重写，而成员变量没有

3、多态的好处与弊端

好处：提高了程序的拓展性

弊端：不能使用子类的特有功能

4、多态的转型

向上转型：由子到父，父类引用指向子类对象：Animal a = new Cat();

向下转型：由父到子，父类引用转为子类对象：Cat c = (Cat) a;

十一、抽象类

1、概述

1. 一个没有方法体的方法定义为抽象方法
2. 有抽象方法的类定义为抽象类

2、抽象类的特点

1. 必须用abstract关键字修饰

   public abstract class ClassName {}
   public abstract void MethodName();

2. 抽象类多态：抽象类参照多态的方式，通过子类对象实例化

3. 抽象类的子类

4. 重写抽象方法

5. 定义抽象类

3、抽象类的成员特点

1. 成员变量：变量and常量
2. 构造方法： 有构造方法但是不能实例化，用于子类访问父类数据的初始化
3. 方法
   1. 抽象方法：限定子类
   2. 非抽象方法：提高代码复用性

十二、接口

1、接口概述

接口是一个公用的规范标准，更多的体现在对行为的抽象

2、接口的特点

1. 接口用interface修饰

public interface 接口名{}

2. 类实现接口用implements表示

public class implements 接口名{}

3、接口的实例化

1. 接口多态：接口不能直接实例化，利用多态实现类对象实例化；
2. 接口的实现类：重写接口的所有抽象方法或者定于抽象类；

4、接口成员的特点

1. 成员变量：只能是常量，默认修饰符：public static final
2. 构造方法：接口没有构造方法，继承或Object类
3. 成员方法：只能是抽象方法，默认修饰符：public abstract

5、类与接口的关系

1. 类与类的关系 --> 继承：只能单继承但是可以多层继承
2. 类与接口的关系 --> 实现：可以继承一个类的时候实现多个端口
3. 接口与接口的关系 --> 继承：单继承与多继承

6、抽象类与接口的区别

1）成员区别

1. 抽象类：变量常量、构造方法、抽象方法、非抽象方法
2. 接口：常量、抽象方法

2）关系区别

1. 类与类：继承：单继承
2. 类与接口：实现：单实现、多实现
3. 接口与接口：继承：单继承、多继承

3）设计理念区别

1. 抽象类：对类抽象，包括属性、行为
2. 接口：对行为抽象，主要是行为

十三、形参和返回值

1、类名作为形参和返回值

类名-->对象(就像：数据类型-->变量)

2、抽象类名作为形参和返回值

抽象类-->子类对象

十四、内部类

1、内部类

1. 概述：类里面定义一个类

2. 格式

   public class 类名{
   	修饰符 class 类名{
   	}
   }

3. 访问特点

   1. 内部类可以直接访问外部类成员，包括私有
   2. 外部类访问内部类需要创建对象

4. 内部类的位置

   1. 成员位置：成员内部类
   2. 局部位置：局部内部类

2、成员内部类

成员内部类创建对象方法

外部类.内部类 对象名 = 外部类对象.内部类对象;
Outer.Inner Oi = new Outer().new Inner();

3、局部内部类

1）格式

public void method() {
	class Inner(){
	}
}

2）访问特点

1. 方法中定义类，外界无法直接调用，需要在方法内部创建对象调用
2. 可以访问外部类成员及变量

4、匿名内部类

1. 前提：存在一个类或者接口
2. 本质：继承了该类或者实现了该接口的子类匿名对象

// 第一种
new 类名或者接口名(){
	重写方法;
}.方法();
// 第二种
类名或者接口名 对象 = new 类名或者接口名(){
	重写方法;
};