Java面向对象笔记（未完持续更新）

类与对象

对象是类的实例表现
对象是特定类型的数据
属性：对象具有的各种静态特征
类
从数据结构的角度来看类就是自己创建了一种新的数据类型。
类也叫做“自定义类型”。
一个java程序中不允许类同名。

//类名必须和文件名相同
public class Merchandise {
     
    String name;
    String id;
    int count;
    double price;
} 

使用成员变量

publi static void main(String[] args){
     
Merchandise m1=new Merchandise();
m1.name="茉莉花茶";
m1.id="1115";
m1.count=100;
m1.price=99.9;
}

点操作符
点操作符是用来访问/操作前面实体的属性的，类似于“的”
Merchandise.name可以读作Merchandise的name。

引用（reference）数据类型
java中的数据类型分为基本数据类型和引用数据类型

m1是一个Merchandise类型的引用，只能指向Merchandise类型的实例；
引用数据类型变量包含两部分信息：类型和实例。
每一个引用数据类型的变量（简称引用），都是指向某个类（class/自定义类型）
的一个实例/对象（instance/object）。不同类型的引用在java的世界但是引用。
引用的类型信息在创建时就已经确定，可以通过给引用赋值，让其指向不同的实例。

Merchandise m1;
m1=new Merchandise();

-声明对象 Merchandise m1
-实例化对象m1=new Merchandise();
使用new操作符可以创建某个类的一个实例。在java程序运行的时候，所以这些创建出来的实例都被java放在内存里一个叫做堆的、类似广告板的地方。
创建一个实例，就是根据类的定义、点才需要的“纸”，订成一个本子，挂在公告板书，实例本身，可以认为是一个小本子。
引用里存放的，相当于某个本子所在的公告板的地址。
类和对象的关系
类是对象的模板，对象是类的一个实例
一个java程序中类名相同的类只能有一个，也就是类型不会重名
一个类可以有很多对象
一个对象只能根据一个类来创建

引用和类以及对象的关系
引用必须是、只能是一个类的引用
引用只能指向其所属的类型的类的对象
相同类型的引用之间可以赋值
只能通过指向一个对象的引用，来操作一个对象，比如访问某个成员变量

JAVA中的包和访问修饰符
为了避免类在一起混乱，可以班类放在文件夹里。这时就需要用package语句告诉java这个类在哪个package里。package语句要和源文件的目录完全对应，大小写要一致。
package读作包。一般来说，类都会在包里，而不会直接放在根目录。
不同的包里可以有相同的名字的类。
一个类只能有一个package语句，如果有package语句，则必须是类的第一行有效代码。

import导入包
当使用另一个包里的类的时候，需要带上包名。
每次使用都带包名很繁琐，可以在使用的类的上面使用import语句，一次性解决问题，就可以直接使用类了。就好像Scanner类。
import语句可以有多个。
如果需要import一个包中的很多类，可以使用*通配符。
加载类的顺序跟import导入语句的位置无关

   import包名.*; 只能访问指定包名下的类，无法访问子包下的类。

public
被public修饰的属性，可以被任意包中的类访问。
没有访问修饰符的属性，称作缺省的访问修饰符，可以被本包内的其他类和自己的对象。
访问修饰符是一种限制或者允许属性访问的修饰符。

类的全限定名
包名+类名=类的全限定名。也可以简称为类的全民。
同一个 java程序中全限定名字不可重复。

函数重载
一个类可以有多个构造函数，只要它们的参数表不同。
创建对象的时候给出不同的参数值，就会自动调用不同的构造函数。
通过this（）还可以调用其他的构造函数。
一个类里的同名但参数表不同的函数构成了重载关系。

单一职责原则
有且只有一个引起功能变化的原因

this
访问当前类的成员方法
访问当前类的成员属性
访问当前类的构造方法
不能在静态方法中使用

封装

将类的某些信息隐藏在类内部，不允许外部程序直接访问
通过该类提供的方法来实现对隐藏信息的操作和访问
隐藏对象的信息
留出访问的接口

特点：
1.只能通过规定的方法访问数据
2.隐藏类的实例细节，方便修改和实现

步骤
1.修改属性可见性–private 限定只能在当前类内访问
2.创建get/set方法
在get/set方法中添加对属性的限定

static关键字

静态 静态成员
共用同一块存储空间
1.类对象共享。
2.类加载时产生，销毁时释放，生命周期长。
静态成员访问方式：
1.对象.成员
2.类.成员

static+方法 类方法、静态方法、
静态方法不能直接访问同一个类中非静态成员，只能直接调用同一个类中的静态成员。
只能通过对象实例化后，对象.方法的方式访问非静态成员。

在方法中通过对象作为参数，传递的是它的引用，可以通过引用获取该对象所有信息。

继承

一种类与类之间的关系。
使用存在的类的定义作为基础建立新类。
新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。

extends

class Dog extends Animal{
     
}
class Cat extends Animal{
     
}

父类的构造不允许被继承、不允许被重写，但会影响子类对象的实例化过程
方法重写
语法规则：
返回值类型
有继续关系的子类中
方法名相同，参数列表相同（参数类型、顺序、个数、），方法返回值可以允许是子类类型
访问修饰符，访问范围需要大于等于父类的访问范围
与方法的参数名无关

访问修饰符
private：只允许在本类中进行访问
public：允许在任意位置访问
protected：允许在当前类、同包子类/非子类、跨包子类调用、跨包非子类不允许、
默认：允许在当前类、同包子类/非子类调用；跨包子类/非子类不允许调用

super
super 代表父类引用
访问父类成员方法 super.print()；
访问父类属性super.name；
访问父类构造方法super()；
子类构造默认调用父类无参构造方法
可以通过super()调用父类允许被访问的其他构造方法
super()必须放在子类构造方法有效代码第一行

继承后的初始化顺序
父类静态成员
子类静态成员
父类对象构造
子类对象构造

Object类
Object类是所有类的父类
一个类没有使用extends关键字明确标识继承关系，则默认继承Object类（包括数组）
java中的每个类都可以使用Object中定义的方法

final
final class：不允许被继承。
final方法：该方法不能被子类重写，但是可以正常被子类继承使用。
final 方法类局部变量：主要在具体被使用之前进行赋值即可，一旦被赋值不允许被修改。
类中成员变量：赋值过程：1.定义直接初始化2.构造方法3.构造代码块

修饰变量表示不允许修改
基本数据类型的变量-初始赋值之后不能更改
引用类型的变量-初始化之后不能再指向另一个对象，但对象的内容是可变的

可配合static使用
使用final修饰可以提高性能，但会降低可扩展性。

注解
可以声明在包、类、属性、方法、局部变量、方法参数等前面，用来对这些元素进行说明、注释、

设计模式

软件开发人员在软件开发过程中面临的一般问题的解决方案。

单例模式
目的：使得类的一个对象成为该类系统中的唯一实例
定义：一个类有且仅有一个实例，并且自行实例化向整个系统提供
要点
1.某个类只能有一个实例
2.必须自行创建实例
3.必须自行向整个系统提供这个实例
实现
1.只提供私有的构造方法
2.含有一个该类的静态私有对象
3.提供一个静态的公有方法用于创建、获取静态私有对象

优点
1.在内存中只有一个对象，节省内存空间
2.避免频繁的创建销毁对象，提高性能
3.避免对共享资源的多重占用
缺点
1.扩展比较困难
2.如果实例化后的对象长期不利于，系统将默认为垃圾进行回收，造成对象状态丢失
使用场景
1.创建对象时占用资源过多，但同时又需要用到该类对象
2.对系统内资源要求统一读写，如读写配置信息
3.当多个实例存在可能引起程序逻辑错误，如号码生成器

多态

允许不同类的对象对同一消息做出不同的响应。
编译时多态
设计时多态
方法重载
运行时多态
程序运行时动态决定调用哪个方法
必要条件
满足继承关系
父类引用指向子类对象

向上转型
父类 引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有方法
小类转型为大类
注意：父类中的静态方法无法被子类重写，所以向上转型之后，只能调用到父类原有的静态方法

Animal one=new Animal();
        Animal two=new Cat();
        Animal three=new Dog();

向下转型
子类引用指向父类对象，此处必须进行强转，可以调用子类特有的方法
必须满足转型条件才能进行强转
instanceof运算符：返回true/false

     
        if(two instanceof Cat)｛
        Cat temp=(Cat)two; 
		｝
        

抽象类abstract
不允许实例化，可以通过向上转型，指向子类实例

应用场景：
某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
抽象方法：不允许包含方法体；子类中需要重写父类的抽象方法，否则 ，子类也是抽象类
static final private不能与abstract并存
使用规则
1.abstract定义抽象类
2.抽象类不能直接实例化，只能被继承，可以通过向上转型完成对象实例
3.abstract定义抽象方法，不需要具体实现
4.包含抽象方法的类是抽象类
5.抽象类中可以没有抽象方法

接口
接口定义了某一批类所需要遵守的规范
接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。

接口中抽象方法可以不写abstract关键字
访问修饰符默认public
当类实现接口时，需要去实现接口中的所有抽象方法，否则需要将该类设置为抽象类。

接口也可以实现继承，并且可以继承多个父接口

内部类
成员内部类
1.内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化
2.内部类的访问修饰符，可以任意，但是访问范围会受到影响
3.内部类可以直接访问外部类的成员，如果出现同名属性，优先访问内部类中定义的
4.可以使用外部类.this.成员的方式 访问外部类中同名的信息
5.外部类访问=内部类信息，需要通过内部类实例，无法直接访问
6.内部类编译后.class文件命名：外部类$内部类.class

静态内部类
1.静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例
2.静态内部类对象实例时，可以不依赖于外部类对象
3.可以通过外部类.内部类.静态成员的方式，访问内部类中的静态成员
4.当内部类属性于外部类属性同名时，默认直接调用内部类中的成员
如果需要访问外部类中的静态属性，则可以通过外部类.属性的方式
如果需要访问外部类中的非静态属性，则可以通过new外部类（）.属性的方式

方法内部类/局部内部类
1.定义在方法内部，作用范围也在方法内
2.和方法内部成员使用规则一样，class前面不可以添加public、private、protected、static
3.类中不能包含静态成员
4.类中可以包含final、abstract修饰的成员

匿名内部类
1.匿名内部类没有类型名称、实例对象名称
2.编译后的文件命名：外部类$数学.class
3.无法使用private、public、protected、abstract、static修饰
4.无法编写构造方法，可以添加构造对代码块
5.不能出现静态成员
6.匿名内部类可以实现接口也可以继承父类，但是不可兼得