概念
面向对象编程（Object-oriented Programming，OOP）是一种广泛应用于软件开发的编程范式。它通过将数据和对数据操作的方法封装在一个独立的实体中，即对象，来组织和管理代码。面向对象编程强调在编程过程中模拟真实世界中的实体和其相互关系。
定义类
我们需要搞清楚几件事情：对象是根据类创建来的，类是根据现实生活中的事物抽象而来的。
把事物的属性定义为类中的成员变量。
把事物的行为(功能)定义为类中的成员变量。
三个基本特征
Java面向对象的三个基本特征是封装、继承和多态，这三个基本特征是面向对象编程的核心。
一、对象和封装
面向对象三大特征之一——封装
1、封装的概念
将类的某些信息（属性）隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
2、封装的两大原则
1）把尽可能多的东西隐藏起来，对外提供便捷的接口
2）把所有的属性藏起来
二、封装的实现
1、封装步骤
1）修改属性的可见性
2）创建公有的getter/setter方法
3）在getter/setter方法中加入属性控制语句
2、封装的好处
1）便于使用者正确使用系统，防止错误修改属性
2）有助于系统之间的松耦合（耦合是两个或多个模块之间的相互关联，模块之间的耦合度越高，维护成本越高。因此，在系统架构的设计过程中，应减少各个模块之间的耦合度，以提高应用的可维护性），提高系统独立性
3）提高软件的可重用性
4）降低了构建大型系统的风险
三、访问权限控制
1、类的访问控制
1）public修饰符：公有访问级别
2）默认修饰符：包级私有访问级别
2、类成员的访问控制
访问权限修饰符
3、封装代码案例
public class Penguin {
// 定义属性 用private修饰
private String name;
private int health;
private int love;
public Penguin() {
}
public Penguin(String name, int health, int love) {
this.name = name;
this.health = health;
this.love = love;
}
// 因为name、health、love被隐藏在类的内部，外部程序不能直接访问，所以提供公共的get/set方法给外部程序直接访问这些属性
// 获取name、health、love值
public String getName(){ // get是返回值
return name;
}
public int getHealth(){
return health;
}
public int getLove(){
return love;
}
// 设置name、health、love值
public void setName(String name){
this.name=name;
}
public void setHealth(int health){
// 对传递过来的health值进行判断
if(health<0||health>100){
System.out.println("你赋予的健康值不合理，默认赋值为80");
this.health=80;
return; // 如果健康值不合理为负值或大于一百，则赋值为80并返回
}
this.health=health; // 如果健康值合理，则直接赋值
}
public void setLove(int love){
// 对传递过来的love值进行判断
if(love<0||love>100){
System.out.println("你赋予的亲密度值不合理，默认赋值为90");
this.love = 90;
return;
}
this.love=love;
}
// 定义方法输出Penguin属性信息
public void printInfo(){
System.out.println("昵称："+this.name+"，健康值："+this.health+"，亲密度："+this.love);
}
}
四、访问权限控制
1、类的访问控制
1）public修饰符：公有访问级别
2）默认修饰符：包级私有访问级别
2、类成员的访问控制
访问权限修饰符
五、static修饰符
1、static修饰代码块
静态代码块，当Java虚拟机加载类时，就会执行该代码块
1）如果有多个静态块，按顺序加载
2）每个静态代码块只会被执行一次
2、static修饰变量
1）类变量（静态变量）
被static修饰的变量
在内存中只有一个拷贝
类内部，可在任何方法内直接访问静态变量
其它类中，可以直接通过类名访问
2）实例变量
没有被static修饰的变量
每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响
3、static变量的作用
1）能被类的所有实例共享，可作为实例之间进行交流的共享数据
2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间
4、static修饰方法
1）静态方法：可直接通过类名访问
静态方法中不能使用this和super
不能直接访问所属类的实例变量和实例方法
可直接访问类的静态变量和静态方法
2）实例方法：通过实例访问
可直接访问所属类的静态变量、静态方法、实例变量和实例方法
3）静态方法必须被实现
main()就是最常用的静态方法
理论和一些重点：
二，继承
面向对象三大特征之一——检查
1.继承基本介绍
当多个类存在相同的属性[变量]和方法时，可以从这些类中抽象出 父类，在父类中定义这些相同的属性和方法，只需要通过 extends 来 声明继承父类即可
2.继承的基本语法
class 子类 extends 父类{
}
1、子类会自动拥有父类定义的属性和方法
2、父类又叫 超类、 基类、
3、子类又叫派生类
3.继承的细节和注意事项
1、子类 继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性不能在子类 直接访问，要通过父类提供的公共的方法去访问
理论和写法：
三，多态
1.认识多态
概述：同类型的对象，表现出不同的形态（即 同一种事物，由于条件不同，产生的结果也不同）
多态：同一个引用类型，使用不同的实列而执行不同操作
多态的表现形式：父类类型 对象名称 = 子类对象
多态的前提：
有继承（类）/实现关系（接口）
有父类引用指向子类对象 . Fu f = new Zi( );
有方法重写
多态的好处：
使用父类型作为参数，可以接受所有子类对象
体现多态的扩展性与便利
2.多态调用成员的特点
-
变量调用：编译看左边，运行也看左边
-
方法调用：编译看左边，运行看右边
类型转换（父与子）：
- 向上转型：子类转父类（自动类型转换）
- 向下转型：父类转子类（强制类型转换）
- instanceof：判断是否可以转换为指定类型
-
3.多态的优势和弊端
-
多态的优势：
在多态形势下，右边的对象可以实现解耦合，便于扩展和维护。
方法中，使用父类型作为参数，可以接受所有子类对象
多态的弊端：不能使用子类的特有功能如果一定要使用子类特有的功能需要进行强制类型转换，强制类型转换能解决什么问题？
可以转换成真正的子类类型，从而调用子类独有的功能。
转换类型与真实对象类型不一致会报错
转换的时候用instanof 关键字进行判断
定义和理论：
四.抽象类和接口
1、抽象类的概念
抽象： 所谓抽象就是抽出像的部分。是从多个事物中将共性的，本质的内容抽取出来。
抽象方法： 多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的 方法称为抽象方法。
抽象类： 包含抽象方法的类就是抽象类。
2、抽象类的定义和使用
其实抽象类的语法并不难理解，无非是增加了abstract关键字，多了一些限制：
abstract class Person {
private String name;
private int age;
//抽象方法
abstract public void doSport();//抽象方法，只声明不实现
//普通方法
public void eat() {
System.out.println(name+"吃饭!");
}
public void sleep() {
System.out.println(name+"睡觉！");
}
//构造器
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
class Student extends Person {
//必须帮助抽象父类实现构造
public Student(String name, int age) {
super(name, age);
}
//必须重写抽象方法
@Override
public void doSport() {
System.out.println("唱，跳，rap，打篮球！");
}
}
//抽象类的使用
public class Test {
public static void main(String[] args) {
Student student=new Student("路人甲",18);
Person person=student;//通过接收子类引用达到使用目的
person.doSport();
person.eat();
person.sleep();
}
3、抽象类的特性
通过上面的例子我们大致了解了抽象类的定义和使用，下面就总结一下抽象类的特性：
抽象类不能直接实例化对象。抽象类的存在就是被继承的。
抽象方法不能被private、final和static修饰，因为抽象方法要被子类重写，需要满足重写条件。
抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，除非子类也是abstract修饰的抽象类。
抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。
抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量。
4、抽象类的作用
抽象类本身不能被实例化，要想使用，只能创建该抽象类的子类。然后让子类重写抽象类中的抽象方法。抽象类不能实例化，这让人看上去只是相比普通父类类增加了一个不必要的限制。其实不然：
使用抽象方法，而非空方法体，子类就知道他必须要实现该方法，而不可能忽略。
使用抽象类，类的使用者创建对象的时候，就知道他必须要使用某个具体子类，而不可能误用不完整的父类。
理论：
五，异常
1.异常的含义
（1）异常是指在程序的运行过程中发生的不正常事件，如所需文件找不到、网络连接不通或连接中断、算术运算出错（如被零除）、数组下标越界、装载一个不存在的类、对null对象操作、类型转换异常；
（2）异常会中断正在运行的程序（抛出异常的代码，后面的程序不会运行）；
（3） 可以通过增加if-else语句对各种异常情况进行判断处理，但有很多缺点：
代码臃肿，加入了大量的异常情况判断和处理代码；
程序员把相当多的精力放在了异常处理代码上，放在了“堵漏洞”上，占用了编写业务代码的时间，必然影响开发效率；
很难防止所有的异常，程序仍旧不健壮；
异常处理代码和业务代码交织在一起，影响代码的可读性，加大日后程序的维护难度。
（4） Java提供了异常处理机制，可以由系统来处理程序在运行过程中可能出现的异常事件，使程序员有更多精力关注于业务代码的编写。
二、Throwable类
英文单词：throwable 可抛出、可测试 ； error 错误 ； exception 例外的事物
1、Java中有很多类型类型的异常，异常在java.lang包先被封装成了各种异常类；
2、Throwable类是Java语言中所有错误或异常的超类（父类），只有当对象是此类（或其子类之一）的实例时，才能通过Java虚拟机或者Java throw语句抛出。类似地，只有此类或其子类之一才可以是catch子句中的参数类型。
3、Throwable类有两个直接已知子类：Error类和Exception类； 通常用于指示发生了异常情况。
三、 Error类和Exceptio类
我们平常编程会遇到两种两种错误：第一种就是我们在编码期间就报错的错误，我们必须修改好后程序才能启动，这就是Exception异常；第二种是我们编码期间不报错，运行报错，然后我们回来修改代码的错误（编程参数给错，运行结果不是想要的不算），这就是RuntimeException类异常。
还有一个Error类错误是我们无能为力的，这种异常我们是不处理的，比如你的电脑硬件或内存资源不足等问题。
1、Error类
Error是Throwable的子类，用于指示合理的应用程序不应该捕获的严重问题。大多数这样的错误都是异常条件。虽然ThreadDeath错误是一个“正规”的条件，但它也是Error的子类，因为大多数应用程序都不应该试图捕获它。
在执行该方法期间，无需在其throws子句中声明可能抛出但是未能捕获的Error的任何子类，因为这些错误可能是再也不会发生的异常条件。
2、Exception类
Exception类及其子类是Throwable的一种形式，它指出了合理的应用程序想要捕获的条件。
3、RuntimeException类
RuntimeException类是Exception类的子类，RuntimeException是那些可能在Java虚拟机正常运行期间抛出的异常的超类。可能在执行方法期间抛出但未捕获的RuntimeException的任何子类都无需再throws子句中进行声明。
理论：
六，集合
一.集合的概念
1.1什么是集合
在Java中，集合是一种用于存储和操作一组对象的数据结构。与数组相比，集合具有更高的灵活性和更多的操作方法。Java提供了许多集合类，如List、Set和Map等，每个类都有不同的实现方式和适用场景。
1.2集合中具体有啥
集合可以分为Collection（单列集合）和Map（双列集合）
Collection又可以分为Set（不可存储重复元素）和List（可存储重复元素）
Set又可以分为HashSethe和TreeSet
List又可以分为ArrayList，LinkedList和Vector
Map又可以分为HashMap和TreeMap
集合的示意图如下：
二.集合中的Collection单列集合
2.1list集合(可存储重复元素)
在List集合中，接口可以存储重复元素，且存放的顺序就是元素在添加的时候的顺序，同时在此集合中的元素可以通过索引进行访问。
2.1.1Arraylist集合
Arraylist:数据列表。
数组链表在存储的过程中，是以数组的形式进行存储，但是这个数组却是长度可以改变的，且在内存中分配连续的空间。
在创建Arraylist集合之后，系统会默认初始化此数组集合长度，初始化长度是10，当满了之后，就会进行扩容，扩容之后的长度为之前的1.5倍。
public static void main(String[] args) {
ArrayList <String > arrayList = new ArrayList<String >();
arrayList.add("1");//添加元素，默认在末尾添加
arrayList.add("2");
arrayList.add("3");
arrayList.add("4");
arrayList.add("5");
arrayList.add("6");
arrayList.add("7");
arrayList.add("8");
arrayList.add("9");
arrayList.add("10");
arrayList.add("11");
arrayList.add("12");
System.out.println(arrayList);
arrayList.add(0,"a");//指定位置添加元素
System.out.println(arrayList);
// arrayList.clear();//删除数组当中全部元素
boolean b = arrayList.contains("5");//判断是否包含某些内容
System.out.println(b);
System.out.println(arrayList.get(5));//获取指定位置上的元素
int i1 = arrayList.indexOf("5");//判断某元素在数组中的位置
System.out.println(i1);
System.out.println(arrayList.size());//返回数组长度
arrayList.set(4,"66");//替换集合中指定位置的元素
System.out.println(arrayList);
arrayList.remove("3");//删除数组中指定内容
arrayList.remove(8);//删除指定索引
System.out.println(arrayList);
Object obj[] = arrayList.toArray();//转换为Object类型
System.out.println(Arrays.toString(obj));
String s1 [] = arrayList.toArray(new String[arrayList.size()]);//转换为字符串数组
System.out.println(Arrays.toString(s1));
}
运行结果：
2.1.2LinkedList集合
此集合与ArrayList集合的方法名相同，但是底层实现却不相同。
此集合在底层为链表结构，不存在扩容的问题。
并且相比于Arraylist集合，多了一些方法，如下所示：
public static void main(String[] args) {
LinkedList<String > linkedList = new LinkedList<>();
linkedList.add("ss");
linkedList.add("bb");
linkedList.add("rr");
linkedList.add("dd");
linkedList.add("cv");
linkedList.add("uu");
linkedList.addFirst("xx");//向头结点添加
linkedList.addLast("ss");//向尾结点添加
linkedList.removeFirst();//删除头结点
linkedList.removeLast();//删除尾结点
System.out.println(linkedList);
}
结果如下所示：
[ss, bb, rr, dd, cv, uu]
2.1.3Vector集合
此集合和Arraylist集合就只有一个区别，就是此集合是线程安全的，加了同步锁，其他都是一样的。
2.2 Set集合
Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的
2.2.1HashSet集合
此集合中元素的存放顺序是无序的，既不按照存放的顺序存放，也不按照内容的顺序存放。
它是先用hashcode（）计算出哈希值，之后再用equals，以此来进行去重。
存储自定义对象时吗，类中默认没有重写hashcode（），调用的是Object类中的。
七.JavaAPI
一.API的概念
API(Application Programming Interface)应用程序编程接口：是对java预先定义的类或接口功能和函数功能的说明文档，目的是提供给开发人员进行使用帮助说明。
二.Object类
是所有Java类的祖先（根基类）。每个类都使用 Object 作为超类（父类）。所有对象（包括数组）都继承实现这个类的方法。
public class Person { ...
}
等价于：
public class Person extends Object {
...
}理论：
八.JavaI/O
理论：
九.多线程
最后一张笔记比较多，要详细的可以找我
理论：
