【JavaSE】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 父类名{}
  1. 继承的优缺点
    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 接口名{}
  1. 类实现接口用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 类名或者接口名(){
	重写方法;
};

你可能感兴趣的:(java,学习,笔记)