初识面向对象

1、面向对象

1.1 面向对象和面向过程的区别

1. 面向对象：面向对象会把事物抽象成对象的概念，先抽象出对象，然后给对象赋一些属性和方法，然后让每个对象去执行自己的方法。
2. 面向过程：把事情拆分成几个步骤（相当于拆分成一个个的方法和数据），然后按照一定的顺序执行。

1.2 构造方法

概念：主要用于创建对象时调用，并给对象的属性初始化赋值
语法：权限修饰符 方法名/类名(参数列表){方法体}
注意事项：

1. 构造方法没有返回值，void也不行，构造方法的方法名要和类名一致
2. 类中没有定义构造方法时，则有一个默认的无参构造，定义了构造方法则不会提供默认的无参构造

//有参构造
public DuiXiang(int i){
}
//无参构造
public DuiXiang(){
}

1.3 类和对象

类：类是描述一类事物的属性和特征
对象：

1. 代码角度：new的一个实例，封装了成员属性
2. 数据角度：封装数据和逻辑的一种方式
3. 现实角度：对象就是某一个具体的个体，一切皆对象
4. 设计角度：从一个实际的实体中抽象出来某些属性的一种实体表示

对象是类的一个实例，也就是某一个具体的个体
类中封装属性，对象封装属性值

1.4 实例化

1. 加载相关类到方法区
2. 在堆内存开辟内存空间
3. 调用构造方法，在栈内存开辟栈帧，并对堆内存进行数据初始化
4. 构造方法弹栈，返回堆内存内存地址

1.5 对象使用

对象.成员属性

//对象.成员属性
s1.setName("王五");

属性私有化,提供对应的getter/setter方法,提供有参构造和无参构造

//学号
private int id;
public int getId() {
    return id;
}
public void setId(int id){
    this.id = id;
}
//调用
s1.setName("王五");
System.out.println(s1.getName());
System.out.println(s2.getName());

1.6 常见异常

空指针异常：当使用null值，访问成员属性时，容易出现空指针异常

1.7 对象调用静态属性

Star s1 = new Star();
Star s2 = new Star();
s1.a = 3;
System.out.println(Star.a);
//编译后，会自动把s1和s2转变为Star类名调用
//所以，尽管s1是null访问静态属性 也不会出现空指针
s1 = null;
System.out.println(s1.a);
System.out.println(s2.a);

1.8 注意事项

1.8.1 静态调用成员

需要创建对象后在调用

1.8.2 传值和传引用

传值:传递的是值的副本。方法中对副本的修改，不会影响到调用处
传引用:传递的是引用的副本，共用一个内存，会影响到调用处

1.8.3 静态变量和成员变量

静态变量:值，是类的所有对象共享
成员变量:值，是对象独享，多个对象之间值不共享
如果方法中需要用到成员属性，则该方法一定是成员方法，反之则是静态方法

1.8.4 成员方法和构造方法

构造方法的名称必须与类名相同，没有返回类型
成员方法的名称可以是类名，也可以自定义构造方法，有返回类型

2、This

this：是每个对象中，保存自身内存地址的一个引用类型变量（成员变量）
this无法再静态上下文中使用

2.1 作用

1. 用在成员方法和构造方法中，区分同名的局部变量和成员变量

//参数列表就是局部变量
public void setAge(int age) {
//this中year为成员变量
    this.age = age;
}

2. 用在构造方法中，用于重载调用当前类中其他构造方法，提高代码重用性

public This_01(int year, int month, int day) {
		this.year = year;
		this.month = month;
		this.day = day;
}
public This_01() {
    // this() 必须写在构造方法中
//		重载调用当前类中其他构造方法，但是必须在构造方法第一行
		this(1970, 1, 1);
}

3. return this 可以链式调用

public This_01 m1(){
    System.out.println("m1执行了");
    return this;
}
public String m2(){
    System.out.println("m2执行了");
    return "adas";
}
public static void main(String[] args){
    This_01 t = new This_01();
    t.m1();
    t.m2();

    This_01 t1 = t.m1();
    t1.m2();
    //链式调用
    //核心点：前者方法的返回值，是可以调用后者方法的引用
    System.out.println(t.m1().m2().trim().toCharArray());
}

3、Static

static关键字，是修饰静态的修饰符

3.1 作用

1. 修饰静态变量
2. 修饰静态方法
3. 修饰静态语句块

3.2 使用

静态方法的优先级要高于静态变量，静态变量和静态语句块的优先级相同

// 静态变量
static int a = 2;
// 静态方法
public static void m1() {
}
// 静态语句块，可以看作一个没有名字的静态方法
// 在程序加载时，自动调用执行，并且只执行一次（main方法之前）
// 一般用于类初始化使用
static {
    System.out.println("静态语句块1");
}
static {
    System.out.println("静态语句块2");
}
public static void main(String[] args){
    System.out.println("main方法");
}

3.3 实例语句块

一般对象初始化写在构造方法中，很少写在实例语句块中

static {
		System.out.println("静态语句块");
	}
	// 实例语句块，等同于成员方法，创建对象的时候执行，并且创建一次执行一次
	{
		System.out.println("实例语句块");
	}

	Static_02() {
		System.out.println("构造方法");
	}

	public static void main(String[] args) {
		System.out.println("main");
		new Static_02();
		new Static_02();
	}

结果：

4、封装

4.1 Package

package软件包机制，方便分类管理，可以解决命名冲突问题
一般采用公司域名倒叙的方式命名
在java中.package语句是限制class文件的保存位置，与java文件无关
package语句可以不写，如果写的话，必须在java源文件的第一行

4.2 import

4.3 权限控制

5、继承

继承是从已有类中派生出新的类，新的类会拥有父类的属性和行为

1. java只支持单继承，这样使java类关系比较简单
2. 一个类可以被很多类继承
3. java中继承是可以被传递的
4. 如果一个类没有显示继承另一个类的话，默认继承Object，Object是java提供的根类

继承目的：代码复用
语法：通过extends表示
class 类名 extends 父类名 {}

class SupClass{
    public void m1(){
        System.out.println("父类M1");
    }
}
class SubClass extends SupClass{
    public void m2(){
        System.out.println("子类M2");
    }
}

6、Super

Super：在子类中，通过this表示当前对象，通过Super表示父类

6.1 作用

1. 用在成员方法和构造方法中,区分父子类同名的属性
2. 用在构造方法中,用于重载调用父类的构造方法super(),必须写在子类构造方法第一行
3. 而 this() 也必须在构造方法第一行,所以 this() 和 super() 不能同时出现
4. 如果子类构造方法中,没有写this(…) , 也没有写super(…) , 则 第一行默认有super() 去调用父类无参构造
5. this和super都不能在静态上下文中使用

6.2 使用

6.2.1 区分父子类同名属性

class SubClass extends SupClass {
    int a = 2;
    public void m1() {
        // 子类
        System.out.println(a);
        // 父类
        System.out.println(super.a);
    }
}

6.2.2 调用父类构造

子类创建对象，一定会执行父类构造方法

6.3 注意

public class Super_03 {
    private Super_03() {

    }
}
class Test extends Super_03{
    Test(){
        // 注意 , 父类构造方法如果私有化,则不能被继承
        super();
    }
}

7、覆写Override

子类对父类方法进行重写编写
当父类功能无法满足子类需求的时候，子类可以根据需求进行覆写
覆写条件 :

1. 必须是有继承关系的体系中
2. 方法名,参数列表,返回值必须一致
3. 不能比原方法有更低的访问权限
4. 不能比原方法有更宽泛的异常
5. 方法覆写,特指成员方法(只有成员方法可以覆写)

overload 和 override 的区别?
overload 是方法重载,方法名相同,参数列表不同,参数列表可以是个数不同也可以是类型不同
override 是方法覆写,要求方法名,参数列表,返回值必须一致,不能有更低的访问权限,不能有更宽泛的异常…

8、Final

Final是个修饰符，表示最终的不可修改的

8.1 使用

1. final修饰的类 不能被继承
2. final修饰的成员方法,不能被覆写
3. final修饰的成员变量,没有默认值,必须显示赋值(不能有不赋值的情况),不能二次赋值
4. final修饰的静态变量,是常量,没有默认值,必须显示赋值(不能有不赋值的情况),不能二次赋值
5. 一般会和public一起使用 , psf : public static final , 并且常量名,一般全大写
6. final修饰的局部变量,不能二次赋值