Java基础--面向对象1

1.方法（即函数）
定义：完成特定功能的代码块
格式：修饰符/public static/ 返回值类型 方法名（参数类型 参数名1，······）{
方法体 ； /完成功能的代码/
return 返回值； /功能的返回结果/
}
书写的两个明确：返回值 结果的参数类型
参数 参数的个数，以及类型
方法的注意事项
A:方法不调用不执行
B:方法与方法是平级关系，不能嵌套定义
C:方法定义的时候参数之间用逗号隔开
D:方法调用的时候不用在传递数据类型
E:如果方法有明确的返回值，一定要有return带回一个
2.方法重载
定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可
特点：
a.与返回值类型无关，只看方法名和参数列表
b.在调用时，虚拟机通过参数列表的不同来区分同名方法
3.类
定义：用来描述现实世界事物
组成：成员变量（类中方法外的变量） 特征
成员方法（没有static修饰的方法） 功能
局部变量与成员变量的区别：
A:在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
B:在内存中的位置不同
成员变量 堆内存
局部变量 栈内存
C:生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值
成员变量 有默认初始化值
局部变量 没有默认初始化值
4.封装
定义：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
优点：
A:提高了代码的复用性
B:提高安全性
体现：
将不需要对外提供的内容都隐藏起来。
做法：
把属性隐藏，提供公共方法对其访问。

 private（私有的）关键字    
      作用：可以修饰成员变量和成员方法，被private修饰的内容，只能在本类中访问。
 this关键字    
      作用：演示修改局部变量的变量名和成员变量相同的话的效果，局部变量如果有一个变量和成员变量名称一致，那么优先使用的是局部变量。就近原则。 

5. 构造方法：
作用：给对象的数据进行初始化
格式特点：
A:方法名和类名相同。
public void Student() {}
B:没有返回值类型。
修饰符 返回值类型 方法名(…) {…}
C:没有返回值。
没有用return带明确的值回来。
return;
注意事项
A:如果你不提供构造方法，系统会给出默认无参构造方法
B:如果你提供了构造方法，系统将不再提供默认无参构造方法
a:使用自己给的带参构造。
b:要么自己再提供一个无参构造

                           最好自己给出无参构造方法。        
给成员变量赋值：
    A:通过无参构造创建对象并用setXxx()方法

进行赋值
B:通过带参构造方法
6.static关键字
作用：可以修饰成员变量和成员方法
特点：
A:随着类的加载而加载
B:优先于对象存在
C:被类的所有对象共享，也是我们判断该不该使用静态修饰一个数据的依据。
D:可以通过类名调用
静态变量：类变量
非静态变量：实例变量，对象变量

                    非静态的：创建对象访问
        静态的：可以通过类名，也可以通过对象访问。                

注意事项：
A:在静态方法中是没有this关键字的
原因：静态的内容随着类的加载而加载，this是随着对象的创建而存在，所以，static中不能有this。
B:静态方法只能访问静态的成员变量和静态的成员方法
静态方法只能访问静态的成员。
5.继承
extends关键字可以进行类与类之间的继承
格式：
class 子类名 extends 父类名 {

        } 

    父类：基类，超类
    子类：派生类

学生类：
        成员变量：name,age
        构造方法：无参,带参
        成员方法：getXxx()/setXxx(),eat(),sleep()


    老师类：
        成员变量：name,age
        构造方法：无参,带参
        成员方法：getXxx()/setXxx(),eat(),sleep()    

按照我们刚才对继承的概述，我们可以找一个父类。

    人类：
        成员变量：name,age
        构造方法：无参,带参
        成员方法：getXxx()/setXxx(),eat(),sleep()    

    学生类：继承人类就可以了。
    老师类：继承人类就可以了。

继承的好处：
    A:提高了代码的复用性
        多个类相同的成员可以放到同一个类中
    B:提高了代码的维护性
        如果功能的代码需要修改，修改一处即可
    C:让类与类之间产生了关系，是多态的前提
方法重写(子类的方法名，参数和父类完全一样，将父类方法覆盖)：
1.必须存在继承关系
2.父类的方法满足不了你的需求，此时你就需要重写父类的方法，实现自己想要实现的功能
继承的特点：（代码演示）
    A:Java只支持单继承，不支持多继承。
    B:Java支持多层(重)继承(继承体系)。

什么时候使用继承呢?
    继承中类之间体现的是：”is a”的关系。就是子类必须是父类的对象。
    举例：水果，香蕉
    举例：水杯，水果 (不能采用继承。)
    举例：动物，狗                                   

6.类的组成：
成员变量
构造方法
成员方法

继承间的成员变量关系：
    A:名字不同，非常简单。
    B:名字相同
        首先在子类局部范围找
        然后在子类成员范围找
        最后在父类成员范围找(肯定不能访问到父类局部范围)
        如果还是没有就报错。(仅能在父类找）
        就近原则。                                

super
关键字

  可以调用父类的方法
super:
    super代表父类存储空间的标识(可以理解为父类对象)

this和super的使用区别：
    A:成员变量
        this.成员变量   本类的成员变量
        super.成员变量  父类的成员变量
    B:成员方法
        this.成员方法() 本类的成员方法
        super.成员方法()父类的成员方法 
继承间构造方法的关系：
    子类中所有的构造方法默认都会访问父类中空参数的构造方法(super())


    因为子类会继承父类中的数据，可能还会使用父类的数据。
    所以，子类初始化之前，一定要先完成父类数据的初始化。
    每个子类的构造方法的第一行，有一条默认的语句:
        super();

    注意：仅仅是完成数据的初始化，创建对象目前必须用new申请空间。

假如父类没有无参构造方法,该怎么办呢?
    A:调用父类的其他构造方法。带参构造。
        怎么访问呢?
            super(...)

注意：
    super(…)或者this(….)必须出现在第一条语句上。
    因为如果可以放后面的话，就会对父类的数据进程多次初始化。所以，只能放在第一条语句上。

建议：
    永远给出无参构造方法。

7.final关键字
在实际开发的时候，有些方法的内容一旦写定后，就不允许被改动。
即使是子类，也不允许。
java为了解决这样的问题就提供了一个关键字：final
最终的意思。它可以修饰类,方法,变量。
特点：
修饰方法，方法不能被重写。
修饰类，类不能被继承。
修饰变量，变量的值不能再改动。其实这个时候变量已经变成了常量。

常量：
    A:字面值常量
        'a',12,"hello"
    B:自定义常量
        就是把变量用final修饰。
        定义一个常量。
        final 数据类型 变量名;

8.多态
定义：同一个对象,在不同时刻表现出来的不同状态。
多态的前提：
A:有继承关系
B:有方法重写（不是必要条件，但是只有有了方法重写多态才有意义）
C:有父类引用指向子类对象
成员访问特点
A:成员变量
编译看左边,运行看左边
B:构造方法
子类构造默认访问父类的无参构造
C:成员方法（重点理解）
编译看左边,运行看右边

        为什么变量和方法不一样呢?
            方法重写。
    D:静态成员方法
        编译看左边,运行看左边
        因为静态的内容是和类相关的，与对象无关。             

9.抽象类
抽象类特点:
A:抽象类和抽象方法必须用abstract关键字修饰
B:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
C:抽象类不能实例化
实例化并使用
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
D:抽象类的子类
要么是抽象类
，要么重写抽象类中的所有抽象方法

抽象类的作用：
    强制要求子类必须要重写某些方法。    
类的组成：
    成员变量：
    构造方法：
    成员方法：
抽象类的成员：
    成员变量：可以是变量，也可以是常量。
    构造方法：有构造方法
      构造方法作用：用于子类访问父类数据的初始化。
    成员方法：既可以是抽象的，也可以是非抽象的。
抽象类练习
以后我们在写代码的时候，有这样的分析过程。
分析：
    从具体到抽象。
实现：
    从抽象到具体。
使用：

    使用具体的类。

10.String
定义：是由多个字符组成的一串数据。(字符序列)
构造方法：
public String():无参构造方法
public String(byte[] bytes):把字节数组转换为字符串
public String(char[] value):把字符数组转换为字符串
public String(char[] value,int offset,int count):把字符数组的一部分转换为字符串
public String(String original):把一个字符串转换为字符串
String类的成员方法
A:判断功能
boolean equals(Object obj):比较两个字符串的内容是否相同,严格区分大小写。(用户名,密码)
boolean equalsIgnoreCase(String str):比较两个字符串的内容是否相同,忽略大小写。(验证码)
boolean contains(String str):判断字符串中是否包含一个子串。
boolean startsWith(String str):判断是否以指定的字符串开头
boolean endsWith(String str):判断是否以指定的字符串结尾
boolean isEmpty():判断字符串的内容是否为空
B:获取功能
String类的获取功能：
int length():返回字符串的长度。其实就是字符的个数。
char charAt(int index):返回字符串中指定索引处的字符。
int indexOf(int ch):返回指定的字符在字符串中第一次出现的索引。
明明说的是字符，为什么是int呢?
原因是int类型还可以接收char类型。
97,’a’是一样的效果。
但是如果参数是char类型，你就不能写97了。
int indexOf(String str):返回指定的字符串在字符串中第一次出现的索引。
String substring(int start):截取从start开始到末尾的字符串。
String substring(int start,int end):截取从start开始到end结束的字符串。

C:转换功能
byte[] getBytes():把字符串转换为字节数组
char[] toCharArray():把字符串转换为字符数组
static String valueOf(char[] chs):把字符数组转换为字符串
static String valueOf(int i):把int类型的数据转换为字符串
valueOf():可以把任意类型的数据转换为字符串。
String toLowerCase():把字符串转成小写
String toUpperCase():把字符串转成大写
String concat(String str):拼接字符串,前面我们使用过+进行字符串的拼接，不够专业。

D:其他功能
a:替换功能
String replace(char old,char new)
String replace(String old,String new)
b:去除字符串两端空格

     String trim()                         

11.StringBuffer:
构造方法：
StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16个字符。
StringBuffer(int capacity):构造一个其中不带字符的字符串缓冲区，其初始容量为 capacity个字符。
StringBuffer(String str):构造一个其中带字符的字符串缓冲区，其初始容量为 个字符。

成员方法：
public int length():返回长度（字符数）。实际值
public int capacity():返回当前容量。 理论值
添加功能：添加元素，并返回本身的对象。
A:public StringBuffer append(String str):追加数据,在末尾添加
B:public StringBuffer insert(int offset,String str):插入数据,在指定位置添加
删除功能：
public StringBuffer deleteCharAt(int index):删除指定索引处的字符
public StringBuffer delete(int start,int end):删除从start开始到end结束的数据，包左不包右
替换功能：
public StringBuffer replace(int start,int end,String str):用str替换从start到end的数据

反转功能：
public StringBuffer reverse()
截取功能:返回值类型是String类型，本身没有发生改变
public String substring(int start)
public String substring(int start,int end)
相互转换：

String – StringBuffer
String s = “hello”;
// 方式1
StringBuffer sb1 = new StringBuffer(s);
// 方式2
StringBuffer sb2 = new StringBuffer();
sb2.append(s);

StringBuffer – String
StringBuffer sb = new StringBuffer(“world”);
//方式1
String s1 = sb.substring(0);
//方式2
String s2 = sb.toString();
//方式3
String s3 = new String(sb);