面向对象

###### 面向对象五大原则

```
单一职责原则（SRP）
开放封闭原则（OCP）
里氏替换原则（LSP）
依赖倒置原则（DIP）
接口隔离原则（ISP）
```

方法（）

#### 3、String类

*String，StringBuffer，StringBuilder是一个final类，不可以再被继承，不可以再派生出子类*

String不是一个关键字，是一个类，

*String的默认值是null*

（1）String的定义声明

String name = “ren”

String name = new String(“ren”);

（2）String无法使用 ” ==“ 进行判断

(3）String使用直接赋值的方式后只要是以后声明的字符串内容相同，则不会再开辟新的内存空间

(4)String字符串一旦声明则不可改变

String str = “hello”；

str = str + “world”;//形成了一个新的内存块，新的内存块给了str，原有的内存不会变，而是指向了新的内存块

看到等于号内存一定变string内容不会变，改变的是推内存地址的指向。

看到 ”= “内存一定会变，

(5)字符串替换

String str = “ren”;

str = str.replace(“r”,“e”);//运行结果把r换成了e

str.replace(“r”,“e”);//运行结果不会变，此时是新成了一个内存块里面存着een，因为并没有将它赋值回去，所以并没有变

（6）String 切分

String str = “ren”;

String[] s = str.split("");

System.out.println(Arrays.toString(s));//运行结果就会变为一个数组[r,e,n]

String str = “ren”;

String[] s = str.split(“e”);//将字符串从e切分开

System.out.println(Arrays.toString(s));//得到结果为[r,n]

（7）求长

String str = “ren”;

System.out.println(str.length);

（8）定位

String str = “ren”;

知道角标找内容

System.out.println(str.charAt(3));

知道内容找角标

System.out.println(str.indexOf(“r”));

从后面往前找

System.out.println(str.lastIndexOf(“r”));

从指定位置开始查找指定的字符串位置

System.out.println(str.indexOf(“r”，0));

#### 4、面向对象

##### 1、类

万事万物皆对象，先有对象后有类

对象——>抽象为——>类（封装、继承、多态）——>实例化——>对象

一个对象应该由自己的属性和方法组成

很多个对象中具有相同的属性和方法时，我们就可以将其抽象成类

抽象：提取多个对象相似的关键特征

属性的定义

String name ；

int age;

int height;

Person mate;

类：由属性和方法组成

用自然语言描述一个类时，这套描述的自然语言里

包含所有的名词为属性，可以直接给出一个明确的值

包含所有的动词为对象的行为，行为是一系列动作的集合

从对象创建类的过程是抽象的过程，由类申请内存把内容放到内存里的过程叫实例化，实例化完赋对象

看到new关键字出现就一定会创建一个对象，是一个新开辟的内存，新开辟的内存是对原有的内存的替换，其实真正切换的时候是通过赋值运算符实现的，不是new关键字

创建对象在场景类中

```Java
创建一个对象
A a = new A();
```

##### 2、方法

方法（）：一系列动作的集合，参数为这个方法开始的条件，返回值为方法结束的条件，结果作为返回值存在，如果一个方法规定了一个返回值，就一定会返回一个值。

方法的定义:
访问控制 [static] 返回值类型 方法名（参数列表） {方法体}
参数列表（先写类型，再写形参名)

void:无返回值

对于参数的定义一定是类型加上形参名

动态方法（无static）：必需有对象才能调用它

静态方法（有static）：可以直接调用，不需要对象存在

当定义了一个带有返回值的方法时，必须使它返回一个值，应该加上 return 应该返回的值； 除void外定义为其他类型都必须返回相应的类型值，执行前需要参数传入

如定义为Byte时，返回一个Byte对象，如是byte时，返回一个byte值 ，

```java
//当定义为Byte时返回一个Byte对象，当是byte时返回一个byte值
//除void外定义为其他类型都必须返回相应的类型值//
void hit(String type,int times) {
}
boolean hit1(String type,int times) {
if(2<3) {
return true;
}else {
return false;
}
for(int i = 0;i<10;i++) {
return true;
}
//当写了return后后面不能再加任何输出语句
return false; }
```

###### 不定长参数：

```java
//不定长参数 …转为前面类型数组
//String[] arg 必须传一个值， …可以不传值
//不定长参数一定放在参数列表中后面
//String… int… 等等
void foo(String… arg) { }
```

```java
//方法的定义:
//返回值类型 方法名（参数列表） {方法体}
//参数列表（先写类型，再写形参名)
一个方法调用的简单例子
调用方法进行冒泡排序
import java.util.*;
public class Way{
public static void main(String[] args){
int[] arrays = {12,51,41,21,89,64};
int[] arrays1 = {12,99,21,33,89,4};
sort(arrays);//方法调用
sort(arrays1);
System.out.println(Arrays.toString(arrays));
System.out.println(Arrays.toString(arrays1));
}
//定义了一个返回值为int型数组的方法
public static int[] sort(int[] args){
for(int i = 0;i<args.length;i++){
for(int j = 0;j<args.length-i-1;j++){
if(args[j]<args[j+1]){
int temp = args[j];
args[j] = args[j+1];
args[j+1] = temp;
}
}
}
return args;//返回数组

}
}
```

###### 构造方法：

名字与类名相同，无返回值，没有定义构造方法时Java会自动默认一个空的构造放法，创建对象时会自动调用构造方法，构造方法只能用于对象初始化，定义了构造方法后会覆盖之前的默认的空的构造方法，构造方法在普通方法前定义；

构造方法不带返回值，而普通方法是必须有返回值的，这就是区别他们的方法。即方法名可以和类同名，但是必须有返回值类型，而构造方法没有返回类型。

构造方法,只能是动态状态无static修饰。

this指当前的对象

*当继承时父类没有无参构造方法时，子类必须重写有参数的构造方法*

*构造方法不可以继承*

```Java
Human2(String name) {
//this指代当前的对象
this.name = name;
//特指某个对象的foo,这的this指的是Human2对象
this.foo(this);
}
```

```java

模板类
public class Person{
//一个对象应该由自己的属性和方法组成
//很多个对象具有相同的属性和方法时，我们将其抽象为类
//属性的定义
String name;
int age;
int height;
Person mate;
//构造方法,名字与类名相同，下方是系统默认的空的构造方法
Person(){

}
//自定义构造方法
Person(String n){
System.out.println(“创建新对象”)；
name = n;
}

//有参无返回值
void eat(String foodType,int price){ //这的参数为形式参数
System.out.println(name + “吃饭”);//成员变量可以在成员方法中直接引用
System.out.println(foodType+" "+price);

}
//无参有返回值
int earnMoney(){
int a = 3;
int b = 5;
return a-b;
}
}

场景类
class Main{
public static void main(String[] args){
//创建一个Person类的对象p
Person p = new Person();
p.name = “王”;
p.age = 23;
p.height = 188;
//再创建一个新的对象m，将mate传过来时，必须赋给的是一个对象
Person m = new Person();
m.name = “猫”;
p.mate = m;
System.out.println(p.mate.name);

 p.eat("面条",12);//实际参数
 int money = p.earnMoney();
 System.out.println(money);
 }

}
```

当不给name属性和age属性赋值时，成员变量不赋初值可以使用；

class Main{
public static void main(String[] args){
//创建一个Person类的对象p
Person p = new Person();
p.height = 188;

   p.eat("面条",12);//实际参数，此时打印结果为NULL吃饭，String默认结果为NULL
   
   System.out.println(p.age);//此时返回int默认结果0
 }

成员变量在方法外，类内定义，成员变量不赋初值可以使用；基础数据的成员变量都是有默认值的，对象数据类型的初始值时null，成员变量有效范畴在方法外类里任何位置，但是一般在类一进来就开始定义,在static代码块下。

```java
public calss Human{
成员变量
int eyes;
String name;//对象数据类型初始值默认为null

public static void amin(String[] args) {

}
}
```

###### 基础数据类型传值和引用数据类型传值

在方法中定义的非全局基本数据类型变量，调用方法时作为参数是按数值传递的

引用数据类型变量，调用方法时作为参数是按引用传递的，引用类型参数的传值：当参数是引用类型时(数组、对象、接口）

作业：三十个类，有构造方法，有属性

###### Java有5种方式来创建对象：

\1. 使用 new 关键字（最常用）： ObjectName obj = new ObjectName();
\2. 使用反射的Class类的newInstance()方法： ObjectName obj = ObjectName.class.newInstance();
\3. 使用反射的Constructor类的newInstance()方法： ObjectName obj = ObjectName.class.getConstructor.newInstance();
\4. 使用对象克隆clone()方法： ObjectName obj = obj.clone();
\5. 使用反序列化（ObjectInputStream）的readObject()方法： try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME))) { ObjectName obj = ois.readObject(); }