为什么使用面向对象

前言:
面向对象的三大特征
封装 (Encapsulation)
继承 (Inheritance)
多态 (Polymorphism)
编程思想：
面向过程：做某件事情都需要自己亲历亲为，按照步骤去完成
面向对象：做某件事情不需要自己亲历亲为，只需指定特定的对象去完成即可。

1.现实世界就是由对象组成的，如下图，万物皆对象(不是单指女朋友也不是单指男朋友哈~)

2.面向对象设计和开发程序的好处
1.交流更加流畅
2.提高设计和开发效率
3.面向对象的思想符合人类思维习惯

对象和封装

1.类和对象的概念
1.类是对某一事物的描述，是抽象的，概念上的定义。
2.对象是实际存在的该事物的个体，是具体的、现实的。

2.成员变量和局部变量的区别
成员变量：定义在类中，有初始值
局部变量：定义在方法中，无初始值

3.方法的重载：OrverLoad
两同三不同
1，在同一个类中，同一个方法名
2，参数列表不同（个数不同，顺序不同，类型不同）
方法的重载跟返回值无关

4.静态变量（类变量）相当于全局变量
用static修饰的变量叫静态变量也叫类变量
用static修饰的方法叫静态方法也叫类方法
修饰代码块叫静态块（先于main之前调用，先块后main）
可以直接通过类名直接调用 也可以 用对象调用，但是推荐类名调用
静态方法中只能调用静态变量
非静态方法中不能定义静态变量

5.构造方法：方法名和类名相同，没有返回值类型，
每一个类都会有一个默认的无参构造方法
当写了一个有参构造，默认无参构造就会消失
构造方法的作用：
1，实例化对象
2，给成员变量赋值
构造方法包含无参构造和有参构造

封装和继承

1.封装的概念：
将类的某些信息隐藏在类内部，不允许外部程序直接访问，
而是通过该类提供的方法来实现对隐藏信息的操作和访问。
封装的好处：
1，隐藏类的实现细节
2，方便加入控制语句
3，方便修改实现
4，只能通过规定方法访问数据

2.继承：extends
继承是子类对父类的拓展，延伸
继承的特点：
1，关键字 extends
2，java类没有多继承，只有单继承，但是可以多重继承
3，不能继承父类的三种情况 private成员、构造方法、子类与父类不在同包，使用默认访问权限的成员
4，java中所有的类的祖先都是Object类
5，不同的叫法 父类：基类，超类 子类：派生类

3.super: 对父类对象的引用
super(name)：表示调用了父类的的有参构造方法。调用父类的构造方法，必须写在构造方法中的第一行
还可以使用super关键字直接调用父类的方法，如 super.print();(后面的学习还会具体讲)

4.final 最终的
1，修饰变量、常量， 值不可改变
2，修饰方法， 不能被重写
3，修饰类， 不能被继承

5.方法的重写
重写的特点：方法名 参数列表 返回值类型 必须和父类方法一致
访问权限不能比父类的更严格
@Override //注解 规定它下面的方法必须是重写的方法

6.总结：

抽象和多态

1.抽象（abstract）
1，意义：抽象类是一种不完全规范，规定子类必须具备哪些方法
2，特点： 抽象类中可以有普通属性和普通方法
抽象类中有构造方法，但是不能实例化
抽象类只能被继承
抽象方法只能被子类重写或者子类继续抽象
有抽象方法的类必须是抽象类
抽象类中不一定有抽象方法

2.多态
什么是多态：
生活中的多态：不同类型的打印机打印效果不同 如下图：

程序中的多态：
一个对象在不同的载体中呈现不同的形态。
同一个引用类型，调用同一个方法，得到不同的结果。
1，形参多态的必要条件
1，要有继承关系
2，要有方法的重写
3，父类的引用指向子类的对象,

2，用途：可以减少类中的代码量
可以提高代码的可拓展性和可维护性
继承是多态的基础，没有继承就没有多态

3，使用父类作为方法形参和使用父类作为返回值类型是使用多态的常用方式。

3.转型
1，向上转型：把子类转换为父类，属于自动类型转换。
2，向下转型：把父类转换为子类，必须强制类型转换。
注意：
1，向上转型后通过父类引用变量调用的方法是子类覆盖或继承父类的方法，
通过父类引用变量无法调用子类特有的方法。
2，向下转型后可以访问子类特有的方法，必须转换为父类指向的真实子类类型，
否则将出现转换异常（ClassCastException）。

4.instanceof:运算符用于判断一个对象是否属于一个类或实现一个接口。
instanceof:运算符通常和强制类型转换结合使用，先通过instanceof进行类型判断，
再进行相应的强制类型转换。

4.总结

接口

1,接口的定义(interface)：
是一种强制性（完全）的规范。 接口不是一个类，
定义一系列的属性（静态常量）和行为（抽象方法）

2,接口的特征:
1.不能被实例化，接口没有构造方法
2.接口只能被实现implements 或者继续定义为接口
3.接口中的属性默认是 public static fianl 修饰的静态常量
4.接口中的方法默认是 public abstract 修饰的抽象方法
5. 只能有抽象方法
6. 接口中的方法必须被子类重写
7…一个类实现多个接口用逗号隔开
public class Man implements IPerson,Program
8.如果一个类有继承又有实现，那么是先继承再实现
9.接口可以继承多个接口，用逗号隔开！

3,类和类的关系 继承关系
类和接口的关系 实现关系 一个类可以实现多个接口（）
接口和接口的关系 继承关系 可以继承多个接口

4,类只能继承一个父类，但可以实现多个接口，一个类如果实现了一个接口，则必须 实现接口中的全部方法，否则必须将其定义为抽象类。
Java通过实现接口达到了多重继承的效果。

5，接口表示一种约定，接口表示一种能力，接口体现了约定和实现相分离的原则。

6，抽象类利于代码复用，接口利于代码维护。

7.面向接口编程
1，通过面向接口编程，可以降低代码间的耦合性，提高代码的可拓展性和可维护性。
2，面向接口编程意味着：开发系统时，主体构架使用接口，接口构成系统的骨架，这样就可以 通过更换实现接口的类来实现更换系统。

8.接口有比抽象类更好的特性：
1，可以被多继承
2，设计和实现完全分离
3，更自然的使用多态
4，更容易搭建程序框架
5，更容易更换实现

9.接口和抽象类的区别：
1，接口不是类，抽象是是一个类
2，接口没有构造方法，抽象类有构造方法 ，都不可以实例化
3，接口只能被实现 ，抽象类只能被继承
4，接口中只能有公共的静态常量和公共的抽象方法，抽象类中可以有普通的属性和方法
5，接口可以多实现（多继承），抽象类只能单继承

10.总结

异常(exception)

1，什么是异常？
在程序运行过程中，发生了不可预料的错误，导致程序终止。

2，异常的五个关键字：try、catch、finally、throw、throws

3，异常的格式
try{}catch(){}

try{}finally{}

try{}catch(){}finally{}

catch()块可以有多个，但是catch块捕捉有顺序 先子类后父类

4,try代码块中 表示 可能出现异常代码块,catch代码中 捕捉到异常之后的处理。finally 表示不管有没有异常都会执行的代码块

5，finally块中语句不被执行的唯一情况：在异常处理代码中执行System.exit(1)。

6，throw表示抛出异常
throws 表示声明异常 告诉调用者这个方法有异常，谁调用谁处理

7，throw和throws的区别
1.作用不同：throw用于在程序中抛出异常。throws用于声明在该方法内抛出了异常
2.使用的位置不同：throw位于方法体内部，可以作为单独语句使用。throws必须跟在
方法参数列表的后面，不能单独使用。
3.内容不同：throw抛出一个异常对象，而且只能是一个。throws后面跟异常类，而且
可以跟多个异常类。

集合框架

在我的另一篇博文里有详细介绍，下面是链接：
集合框架

多线程

1.进程: 在内存中开辟了一块空间，供程序运行。一个进程表示一个程序的运行。
一个程序可以开多个进程。

2.线程：是程序运行中最小的单位。一个进程可以有多个线程，但至少有一个线程。
进程中执行运算的最小单位，可完成一个独立的顺序控制流程

3.实现多线程的两种方式：
1，写一个类 继承Thread
重写run();方法
通过start();启动线程
如果调用run方法，那么就只有一个main线程
2，实现 Runable接口
重写run();方法
通过代理模式运行start();启动线程

4.设置线程运行的优先级1-10 ：setPriority(10) Thread.MAX_PRIORITY Thread.MIN_PRIORITY
优先级高的线程会获得更多的运行机会。

5.synchronized:同步锁 ：当多个线程对象操纵同一资源时，要使用synchronized关键字来进行资源的
的同步处理，可以使用同步方法和同步代码块来实现。

6.StringBuffer 线程安全 效率低
StringBuilder 线程不安全 效率高
HashTable 线程安全 效率低
HashMap 线程不安全 效率高

7.线程睡眠：sleep()方法使线程转到阻塞状态

8.线程强制运行：join()方法使当前线程暂停执行，等待调用该方法的线程结束后再继续执行本线程。

9.线程礼让：yield()方法、暂停当前正在执行的线程对象，把执行机会让给相同的或者更高优先级的线程。

File和IO流

1、File:

2.File类常用的方法

3.以下是代码演示：

package jbit.io;

import  java.io.*;
public class FileMethods {
	public static void main(String[] args) {
	    FileMethods2 fm=new FileMethods2();
	    File file=null;
	    file=new File("D:\\myDoc\\test.txt");
	    //fm.create(file);
	    fm.showFileInfo(file);
	    //fm.delete(file); 
   }
   /**
    * 创建文件的方法
    * @param file 文件对象
    */
   public void create(File file){
	   if(!file.exists()){
		   try {
			   file.createNewFile();
			   System.out.println("文件已创建！");
		   } catch (IOException e) {
			   e.printStackTrace();
		   }
	   }
   }
   /**
    * 删除文件
    * @param file 文件对象
    */
   public void delete(File file){
	   if(file.exists()){
		   file.delete();
		   System.out.println("文件已删除！");
	   }
   }
   
   /**
    * 显示文件信息
    * @param file 文件对象
    */
   public void showFileInfo(File file){
	   if(file.exists()){ //判断文件是否存在
		   if(file.isFile()){ //如果是文件
			   System.out.println("名称:" +  file .getName());
		       System.out.println("相对路径: " + file.getPath());
		       System.out.println("绝对路径: " + file.getAbsolutePath());   
		       System.out.println("文件大小:" + file.length()+ " 字节");   
		   } 
		   if(file.isDirectory()){
			   System.out.println("此文件是目录");
		   }
	   }else
		   System.out.println("文件不存在");
   }
}

4.java流的分类

5.文本文件的读写
用FileInputStream和FileOutputStream读写文本文件
用BufferedReader和BufferedWriter读写文本文件

6.二进制文件的读写
使用DataInputStream和DataOutputStream读写二进制文件

7.InputStream类常用方法
int read( )
int read(byte[] b)
int read(byte[] b,int off,int len)
void close( )
int available()
子类FileInputStream常用的构造方法
FileInputStream(File file)
FileInputStream(String name)

8.OutputStream类常用方法
void write(int c)
void write(byte[] buf)
void write(byte[] b,int off,int len)
void close( )
子类FileOutputStream常用的构造方法
FileOutputStream (File file)
FileOutputStream(String name)
FileOutputStream(String name,boolean append)

9.Writer类常用方法
write(String str)
write(String str,int off,int len)
void close()
void flush()
子类BufferedWriter常用的构造方法
BufferedReader(Writer out)

10.总结

本文转自：https://blog.csdn.net/weixin_44490662/article/details/103065026