JAVA面向对象基础知识笔记

你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

String的构造方式

1:输入字符串；

String s=sc.nextLine();

2:构建一个空白字符串

public String();

3:根据字符数组的内容，创建字符串对象；

public String(char[] chs); 

4:进行字符串内容比较的方法

public boolean equals(Object anObject);

注意：将字符串变量直接用==相比的是两个引用数据类型的地址值是否相等

5:取得字符串长度：

public int length();

5:返回指定索引处的char值字符串:

public char charAt(int index); 

索引也是从0开始的。

StringBuilder类

StringBuilder构造方法:

1.创建一个空白可变字符串对象，不含有任何内容

public StringBuilder(); 

2.根据字符串的内容，来创建可变字符串对象

public StringBuilder(String str); 

StringBuilder 的添加和反转方法:

1.添加数据，并返回对象本身；

public StringBuilder append();

2.返回相反的字符数列;

public StringBuilder reverse(); 

3.StringBuilder 转化为String:

public String toString();

4.StringBuilder 转化为String:

public String toString();

5.String 转化为 StringBuilder:

public StringBuilder(String s); 

ArrayList类

1.ArrayList构造方法：

创建一个空的集合对象

public ArrayList();  

2.ArrayList成员方法：

1.ArrayList添加方法：

1.将指定的元素追加到此集合的末尾

public boolean add(E e) ; 

2.在此集合中制定位置插入指定的元素

public void add(int index, E element); 

2.ArrayList删除方法：
1.删除指定元素 返回删除是否成功。

public boolean remove(Object o); 

2.删除指定索引处的元素，返回被删除的元素。

public E remove(int index);

3.修改指定索引处的元素，返回被修改的元素

public E set(int index, E element);

4.返回指定索引处的元素

public E get(int index);

5.返回集合元素个数

public int size();

继承

注意事项

在子类构造方法中默认第一句是super();
即默认第一句是父类的无参构造方法被调用
如果要访问本类中的成员变量age要用this关键字
如果要访问父类中的成员变量age要用super关键字

方法重写注意事项
1.私有方法不能被重写(父类私有成员子类是不能继承的)
即在父类中用private修饰的成员，在子类中是不能访问的
只能通过父类的get/set方法访问
2.子类方法访问权限不能更低（public>默认>私有）
即在子类中重写方法时访问权限应该大于等于父类方法

多态

定义
同一个对象，在不同时刻表现出来的不同形态
举例：猫
我们可以说猫是猫，猫 cat = new 猫();
我们也可以说猫是动物 动物 animal = new 猫();
这里猫在不同的时刻表现出来了不同的形态，这就是多态

多态的前提和体现
有继承/实现关系
有方法重写
有父类引用指向子类对象;
使用多态时：访问看左边（即父类有无这个方法或者变量）
执行看右边（即子类重写的方法）

多态的好处：
提高了程序的扩展性

具体体现：
定义方法时，使用父类型作为参数，将来在使用的时候，使用具体的子类型进行操作

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

向上转型：
从父到子，父亲引用指向对象

Animal a= new Cat();//向上转型（多态）

向下转型：
(解决了多态的弊端——不能访问子类独有的功能）
从父到子，父亲引用转为子类对象

Cat c = (Cat)a;//向下转型(就是定义一个子类对象，将父类对象强转为子类对象）

抽象类：

注意事项：

1.抽象类和抽象方法都得用abstract修饰符来修饰
2.并且创建抽象对象会报错
3.抽象类中可以没有抽象方法，但是有抽象方法不可以没有抽象类

抽象类的特点：

1.抽象类必须用abstract关键字修饰

public abstract class 类名{}
public abstract void eat();

2.抽象类不一定有抽象方法，有抽象方法一定是抽象类

3.抽象类不能实例化
可以参照多态的方式，通过子类对象实例化。这叫抽象多态类

4.抽象类的子类
1.要么重写抽象类的所有抽象方法
2.要么是抽象类

接口：

接口的特点：

1.接口用关键字interface修饰

public interface 接口名{}

2.类实现接口用implements表示

public class 类名 implements 接口名{}

3.接口不能实例化
接口如何实例化呢？
可以参照多态的方式，通过类对象实例化，这叫接口多态。

补充：
多态的形式：
具体类多态，抽象类多态，接口多态。后两种用的比较多

4.接口的实现类：
1.要么重写接口中的所有抽象方法
2.要么是抽象类

5.接口的成员特点：

1.成员变量：
只能是常量，默认修饰符public static final

2.构造方法：
接口没有构造方法，接口主要对行为进行抽象，没有具体存在

3.成员方法：
只能是抽象方法，默认修饰符：

public abstract
public abstract void method();
void show();

这里也是默认为上面的public abstract
4.一个类如果没有父类，默认继承自Object类
可以直接使用接口名来访问接口里面的成员变量
例如：Inter.num；

内部类

内部类格式：

public class 类名{	//这是一个类
   	修饰符 class 类名{	//这是一个类里面的内部类
 	}
}

内部类访问特点：
1.内部类可以直接访问外部类的成员，包括私有
2.外部类要访问内部类的成员，必须创建对象

一般来说内部类的修饰符都是private
所以在外部类里面创建一个成员方法，创建对象访问内部类

匿名内部类：

本质:
就是一个继承了该类或者该接口的 子类 匿名对象；

前提：
存在一个类或者接口
这里的类可以是具体类也可以是抽象类

格式：

 new类名或者接口名（）{
重写方法
    };

eg:

new Inner() { //这里相当于新建了一个对象这个对象实现了Inner接口
	public void show() {
		System.out.println("匿名内部类");
		}
	};

Inner i = new Inner(){重写方法}	//这也是使用多态的形式构造

说白了就是左边就是一个接口
右边是它的一个实现子类（匿名内部类）

Math

Math类的常用方法：

1.返回参数的绝对值

public static int abs(int a)

2.返回大于或者等于参数的最小double值，等于一个整数

public static double ceil(double a)

3.返回小于或者等于参数的最大double值，等于一个整数

public static double floor(double a)

4.按照四舍五入返回最接近参数的int

public static int round(float a)

5.返回两个int值中的较大值

public static int max(int a,int b)

6.返回两个int值中的较小值

public static int min(int a,int b)

7.返回a的b次幂的值

public static double pow(double a,double b)

8.返回为double的正值，[0.0,1.0]

public static double random()

System类

Syetem常用的方法：

1.终止当前运行的Java虚拟机，非零表示异常终止

public static void exit(int status)；

System.exit(0); 

2.返回当前时间（以毫秒为单位）

public static long currentTimeMillis();

Object类

Syetem常用的方法：

比较地址相等

public boolean equals(Object anObject);

equals方法本来是比较地址相等
但是在String类中重写了equals方法就比较的是字符串的内容
但是在其余自己建立的类中需要重写equals方法

toString方法也是一样不重写就输出的是一堆地址值
需要重写后才可以输出内容

Arrays 类

包含用于操作数组的各种方法

1.返回指定数组的内容的字符串表示形式

public static String toString(int[] a)

2.按照数字顺序排列指定的数组

public static String void sort(int [] a)

基本类型包装类Integer

静态变量

1.Integer.MAX_VALUE	//整数的最大值2147483647
2.Integer.MIN_VALUE	//整数的最小值-2147483648

构造方法：

public Integer(int value);根据int值创建Integer对象（过时）
public Integer(String s);根据String值创建Integer对象（过时）

静态方法获取对象：

1.返回表示指定的int值的Integer实例

public static Integer valueOf(int i);//返回表示指定的int值的Integer实例

2.返回一个保存指定值的Integer对象String

public static Integer valueOf(String s);//返回一个保存指定值的Integer对象String

int和String相互转化

1.int----String

String s2 = String.valueOf(num);

2.String—int
将Integer对象转化为int

public int intValue();

这个将String转化为int

public static int parseInt(String s)

装箱：
把基本数据类型转换为对应的包装类类型

Integer i = Integer.valueOf(100);

自动装箱：

Integer ii =100;

拆箱：把包装类类型转换为对应的基本数据类型

ii.intValue()；//将包装类类型转化为了int

自动拆箱：

ii+=200;

得到字符串中每一个数字数据

public String[] split(String regex)

eg：去除每个空格然后将其中的字符串装进数组

`String[] st = s.split(" ");`

权限修饰符

pirvate

private: 在同一个类中才可以访问。
默认情况下：在同一个包中子类无关类都可以访问。

protected

protected：可以在不同包的子类中。

public

public：可以在不同包的无关类中。

关键字

final

final:是最终的意思，可以修饰成员方法，成员变量，类。

final修饰的特点：

1.修饰方法：表明该方法是最终方法，不能被重写

2.修饰变量：表明该变量是常量，不能再次被赋值

3.修饰类：表明该类是最终类，不能被继承

static

static:是静态的意思，可以修饰成员方法，成员变量

static修饰的特点：

1.被类的所有对象共享,这也是我们判断是否使用静态关键字的条件

2.可以通过类名调用,当然，也可以用过对象名调用。

static的访问特点：