Java基础2

Java基础2

面向对象

面向：面对、朝向
对象：世界一切的事物
面向对象思想：把人们从执行者变成了指挥者
面向对象的程序开发：就是不断找对象、使用对象、指挥对象做事情的过程。
面向对象思想特征：封装、继承、多态

抽象：把一系列相关事物共同的属性和行为提取出来的过程
类：是一系列具有相同属性和行为的事物的统称
对象：某一类事物的某个具体存在
类是对事物的抽象，是一个模板；
对象是类的具体化，是一个实例；
手机→类
我手里的这部手机→对象

变量：类变量、成员变量、局部变量
方法：类方法、成员方法、构造方法

事物的属性 在类中叫成员变量；
事物的行为 在类中叫成员方法；
成员变量：定义在类中、方法外；
成员方法：去掉static修饰符。

创建对象：
类名 对象名 = new 类名();
对象名是变量名
使用对象：
对象名.变量名
对象名.方法名(// 参数列表)

类是引用类型的变量
引用类型的变量作为参数传递给方法时，传递的是地址值；方法内修改影响原来的值，因为是对地址操作，调用方法后地址所对应的值已经改变。

位置指的是定义位置
局部位置：方法的参数列表中、方法内部
成员位置：类中、方法外

Java中变量的使用规则：遵循“就近原则”

1.如果局部位置有，就使用；
2.没有就去本类的成员位置找，有就使用；
3.还没有就去父类的成员位置找，有就使用，没有就报错！
局部变量→成员变量→父类→更高父类→Obiect

成员变量和局部变量的区别：

注意事项：当成员变量和局部变量重名时，采用就近原则
类变量则存在于方法区中。

封装

构造方法
作用：用来初始化本类对象的

格式：修饰符 构造方法名(参数列表) {
            //方法体
           }

要求：
构造方法名必须和类名相同(包括大小写)
构造方法没有返回值(但可以写return)
构造方法没有返回值类型(void也不能写)
注意：
若没写构造方法，系统会给默认无参构造
若写了构造方法，系统不再给出无参构造
构造方法可以重载

标准的JavaBean类
成员变量：全部用private修饰；
构造方法：要包括无参构造、全参构造；
成员方法：公共的访问方式：setXxx()、getXxx()和其他方法。

/*
	定义一个标准的JavaBean类
*/
public class Student {
	// 成员变量，全部用private修饰
	// 姓名
    private String name;
    // 年龄
    private int age;
	
	// 构造方法，包括无参构造 和 全参构造
	// 无参构造
    public Student() {
    }
    
	// 全参构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
	
	// 成员方法
	// 公共的访问方式，getXxx() 和 setXxx()
	// 设置姓名
    public void setName(String name) {
        this.name = name;
    }
    
	// 获取姓名
    public String getName() {
        return this.name;
    }
	
	// 设置年龄
    public void setAge(int age) {
        this.age = age;
    }
	
	// 获取年龄
    public int getAge() {
        return this.age;
    }
}

快捷键：Alt + Insert，快速生成构造方法和公共访问方式
封装：隐藏对象的属性和实现细节，仅对外提供公共的访问方式。不能让外部类直接访问本类属性，只能通过规定方法访问数据。

继承

extend /ɪkˈstɛnd/ 拓展，延伸，继承
被继承的类叫做父类(基类、超类)；
继承的类叫做子类(派生类)；
子承父业

格式：extends
class 父类 {
    // …
}

class 子类 extends 父类 {
    // …
}

Java中，子类只能继承父类的非私有成员(成员变量、成员方法)。

继承的使用场景：
多个类中存在相同的属性和行为时，可以将这些共性内容抽取出来放到一个新类中，使得新类和这些类产生父子关系，实现代码复用。
共性内容写在父类中；
个性内容写在子类中。

继承的缺点：
打破了父类的封装性；
具有高耦合性。

程序设计的追求：
低耦合，高内聚。
耦合：两个(或更多)模块相互依赖对方
内聚：模块内部结构紧密，独立性强

this.成员变量/方法 表示本类的成员变量/方法
super.成员变量/方法 表示父类的成员变量/方法
this本质是对象
super本质是父类内存空间的标识

对象初始化顺序：
先初始化父类内容，再初始化子类内容。

1.创建子类对象时，必须先(调用父类构造方法来)初始化该对象的父类内容；再(调用本类构造方法来)初始化该对象的本类内容。
2.所以子类所有的构造方法的第一行都有一个默认的super();
super()是用来访问父类的无参构造方法；
super(参数)是用来访问父类的带参构造方法；
–如果父类是无参构造，super()默认省略；
–如果父类是带参构造，必须通过super(参数)的形式访问父类的带参构造。

方法重写(Override)
子类中的方法与父类中的方法 定义相同
–方法名、参数列表、返回值类型都相同

注意：
父类的私有方法无法重写；
子类方法的访问权限 要 ≥ 父类方法的访问权限；
子类方法不能比父类方法抛出更大的异常。

方法重写的场景：
父类方法不能完全满足需求，需要扩展父类方法
父类方法已过时，需要重新实现父类方法；

@Override可以验证子类方法是否是父类方法的重写

方法重载和方法重写的区别：

Java中继承的特点：
1.Java中只支持类的单继承，但是支持多层继承；
2.Java中还支持接口的多继承，语法为：
接口A extends 接口B，接口C，接口D…
多继承指的是extends写后边多个父类；
多层继承指的是子继承父，父继承爷…

3.私有成员(成员变量/方法)不能继承；
4.构造方法不能继承；
5.继承体现了"is a", 子类“是一个”父类时才使用。

变量的本质是内存中的一小块区域，这一小块区域里存储着变量的值。
当变量指向一个对象的时候，这个变量就称为一个引用变量。
指向：对着的意思

A a = new A();
// a是引用变量，它指向一个对象new A()。

多态

多态：多种状态，同一对象在不同情况下表现出不同的状态或行为。
poly mor phic /ˌpɒlɪˈmɔr ːfIk/ 多态

Java中实现多态的步骤：
1.要有继承或实现关系；
2.要有方法重写；
3.要有父类引用(变量)指向子类对象。

比如：

Animal a = new Dog();
Animal是父类，a是父类的引用(变量)；
= 代表指向；
new Dog()代表子类对象。

//以普通的方式创建Animal的对象
Animal a = new Animal();
//以普通的方式创建Dog的对象
Dog d = new Dog();
//以多态的方式创建Dog的对象
Animal an = new Dog();
因为是用Dog的构造方法去初始化的；
Dog的构造方法里需要先初始化父类的内容，
再初始化自己的内容。

实际上分为两步：

1.Animal an;// 声明引用变量an的类型为Animal

在栈内存中创建引用变量an；

2.an = new Dog();// 创建对象

通过关键字new在堆内存中开辟连续内存空间，使用构造方法完成对象的初始化；先初始化父类内容，再初始化子类内容。

Animal是父类，Dog是子类；
子类继承了父类的内容；子类 = 父类 + 本类
父类 变量 = 子类对象；

把子类对象里边 父类的内容+子类重写的方法赋值给左边

封装是隐藏对象的属性和实现细节，仅对外提供公共的访问方式；
继承是子类可以使用父类的非私有成员变量/方法；
多态是父类可以使用子类的重写方法；
引用类型的数据转换使父类可以使用子类的特有方法。

成员变量不能重写，父类的成员变量就是父类的，子类的成员变量就是子类的。

多态中调用成员方法是编译看左，运行看右。
编译看左：编译期间，看左边的类(Animal)中是否存在这个成员方法(eat()),没有就报错；
运行看右：运行时，实际用的是右边的类(Dog)中的成员方法(eat())。

多态中调用成员变量是编译看左，运行看左。
编译看左：编译期间，看左边的类(Animal)中是否存在这个成员变量(name),没有就报错；
运行看左：运行时，实际用的是左边的类(Animal)中的成员变量(name)。

多态的使用场景：
父类类型变量作为形参时，可以接收其任意的子类对象。

**多态的弊端：**不能使用子类特有成员
要想使用，需要先类型转换。

引用类型的数据转换
向上转换：自动，子类型转换成父类型；

Animal a = new Dog();

向下转换：强制，父类型转换成子类型；

Animal an = new Dog();
Dog d = (Dog)an;

an定义是Animal类型的，如果它还是Dog类型的那就可以强转。

if (an instanceof Dog) {
    Dog d = (Dog)an;
}

instance / 'ɪnstəns / 实例
对象 instanceof 类
判断左边对象是否为右边类的实例

Animal类的对象和Dog类的对象在堆内存中开辟的内存区域大小就不一样；
Dog的内容肯定比Animal的多，既有父类的也有自己的内容；
Animal类型的引用变量a 可以指向Dog类的对象
Dog类型的引用变量d 不能指向Animal类的对象

①

Animal an = new Animal();
Dog d = (Dog) an;//报错

你new的是父亲，那他就是父亲；
他本身就是父亲，你把他衣服脱掉，他还是父亲这种真父亲是无法使用儿子的特有方法的。

②

Animal an = new dog();
Dog d = (Dog) an;

你new的是儿子，那他就是儿子；
只是给他穿了一件父亲的衣服，表面上看是父亲，实质还是儿子，所以你可以向下转型，把他衣服脱掉他就变儿子。
他本身是儿子，但是他穿了父亲的衣服，所以他不能调用儿子的特有方法，不然穿帮了；只有他脱了衣服，恢复了他自己的儿子身份，才能调用他自己的特有方法了。

Java中修饰符分为三种：访问权限修饰符、状态修饰符、抽象修饰符。

访问权限修饰符：private，default，protected，public
状态修饰符：final，static
抽象修饰符：abstract

访问权限修饰符

被访问权限修饰符修饰的成员：
private：只能被本类访问；
默认：只能被本包中的类访问；（默认是什么都不写）
protected：可被本包中的类 和 其他包中的子类访问；
public：可被任何类访问。

private和protect：是用来修饰变量(类变量、成员变量)和方法(类方法、成员方法、构造方法)的，不能修饰类(外部类)。
默认和public：是用来修饰类、接口、变量(类变量、成员变量)和方法(类方法、成员方法、构造方法)的。
访问权限修饰符 不适用于 局部变量。局部变量定义在方法中，只在方法内部有效，本身有作用域的限制，不能使用访问权限修饰符。比如main方法中定义的是局部变量，不能加访问权限修饰符。

状态修饰符

final 最终的、最后的
final的作用：用来修饰类、方法、变量

static 静态的
static的作用：用来修饰成员变量、成员方法
static可以把
成员变量→类变量(静态变量)
成员方法→类方法(静态方法)
调用方式：
类名.成员变量名
类名.成员方法名(参数)

static修饰成员变量
成员变量的使用：先创建对象，再对象.成员变量
类变量的使用：直接类.类变量
不需要实例化就可以使用；
被本类及其子类的所有对象共享；
成员方法可以调用静态变量；
一般加上final修饰符变为常量；

static修饰成员方法
静态方法不能使用关键字this；
因为this关键字代表的是对象，静态方法根本不在对象当中，而在类当中。
静态方法不能直接调用非静态成员(方法/变量)；(局部变量可以)。
比如：main方法中不能调用同类的成员方法，如果需要调用，要将该成员方法用static修饰为静态方法。
因为在内存中，先生成的静态方法和变量，后生成的成员方法及变量。

子类是否可以继承父类的static变量和方法？
子类可以继承父类的static变量和方法；但无法重写父类的静态方法。
子类和父类中同名的static变量和方法都是相互独立的，分别存储于两块不同的内存空间中，并不存在任何的重写关系；父类的静态方法属于父类，子类的静态方法属于子类。

使用场景：某方法只访问静态成员，并且不需要通过 对象名.方法 的形式调用。
abstract和static不能共存，抽象方法需要重写，静态方法直接调用。

抽象修饰符

abstract / ˈæbstrækt / 抽象，摘要
imple ment / 'ɪmplɪment / 实现，执行
抽象类：具有抽象方法的类；用abstract修饰
抽象方法：只有方法声明，没有方法体的方法；
用abstract修饰
抽象方法的由来：当需要定义一个方法，却不明确方法的具体实现时，可以将方法定义为abstract，具体实现延迟到子类。
方法重写快捷键：在类名上 Alt + Enter
抽象方法没有方法体，即不需要{}

public abstract void smoke()

抽象类可以有构造方法，但构造方法不能用来实例化对象，只能被子类调用。

抽象类的特点
1.必须用abstract关键字修饰；
2.抽象类不能被实例化，只能通过创建子类对象(多态)来实例化；即父类引用指向子类对象。只能被继承。
3.抽象类的子类：
①如果是普通类，则必须重写父类所有抽象方法
②如果是抽象类，则可以不用。

抽象类的成员比普通类多一种：抽象方法；
抽象类不一定有抽象方法；用abstract修饰即可；
但有抽象方法的类一定是抽象类；
有抽象方法的结构还有接口。

接口

接口是对外提供的一组规则、标准。
接口可以理解为一种特殊的“类”，一种100%的抽象类，只包含全局常量和公共的抽象方法。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。

抽象方法只能存在于抽象类和接口中；
但抽象类中可以有 非抽象方法；
而接口中必须全部是 抽象方法。

定义与类一样
class 类名 {}
interface 接口名 {}
对于类来说，子类使用extends来继承
对于接口，子类使用implements来实现

接口中的属性只能是public static final类型的
方法只能是public abstract类型（默认省略）

接口创建对象的特点：
1.接口不能实例化，需要创建其子类对象来完成实例化操作
2.接口的子类：
-普通类，则必须重写接口中的所有抽象方法
-抽象类，不用重写

接口和类之间的关系：
-类与类之间：继承关系，只能单继承，不能多继承，但可以多层继承
-类与接口之间：实现关系，可以单实现，也可以多实现
类名 implements 接口A，接口B
-接口与接口之间：继承关系，可以单继承，也可以多继承
接口A extends 接口B，接口C

1.一个类继承抽象类，表示“是什么”，抽象类中定义的是该继承体系共性功能。
2.一个类实现接口，表示“做什么”，接口中定义的是该继承体系的扩展功能。
综上所述： 共性功能抽取放入抽象类中，接口相当于扩展功能，让某些···去实现。

相同点：
不能被实例化，只能通过多态的方式创建对象
子类是
-普通类，则必须重写接口中的所有抽象方法
-抽象类，不用重写

不同点：