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

- 日理万妓 2021-08-28 11:37 389阅读 0赞

## 类与对象 ##

对象是类的实例表现  
对象是特定类型的数据  
属性：对象具有的各种静态特征  
**类**  
从数据结构的角度来看类就是自己创建了一种新的数据类型。  
类也叫做“自定义类型”。  
一个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.匿名内部类可以实现接口也可以继承父类，但是不可兼得