java面向对象编程

面向对象的基本特征

面向对象的基本特征包括:抽象、封装、继承、多态，这三大特征后面细写
抽象（个人理解）:将一个具体的事物，根据他的特征和行为，将它抽离成一个不具体的一种概念，一种很大的东西，一种分类，就好比人 根据把它的特征抽离成哺乳动物，一说哺乳动物你并不知道这是一个什么东西，它具体是谁，是哪种动物，你可以通过哺乳动物知道人符合条件，老鼠也符合条件，这里面人和老鼠其实都是哺乳动物的一种具体实例。
没写太清除，看看再描述一遍老师写的笔记:让事物脱离具体化，只将它的类型、属性和行为抽离出来形成一个类，例如针对猫、狗、牛、羊，根据它们的共同特征和共同行为，可以把它们抽象出一个动物类，这个从现实中的物体到程序的类设计就是一个抽象的过程，动物类本身就是泛指，它不指具体的某一种动物，这就是脱离具体化的体现。

1. 构造函数
   用途：在实例化的时候调用,常常用来初始化对象,给对象的属性赋初始值
   书写规则：访问修饰符 类名（[形参]）{
   //内容
   }
   类里面其实有一个默认的无参构造函数，当你没写构造函数的时候会默认使用它！但是当你自己写了构造函数时，这个构造函数就会消失。所以当你写了有参构造函数的时候，在实例化时就要传入参数（因为没有无参的构造函数）这是你要是不需要传入参数的话，你可以加上无参的构造函数，这里就涉及到了方法的重载
   重载：在同类中不同的方法使用相同的方法名(同类中一种多态性的表现)(同名，不同参:包括顺序不一样，数量不一样，类型不一样,返回值可以不同，访问修饰符也可以不一样)

2. static(静态的)关键字: 当你使用static修饰方法或者属性时，你可以把该方法或者属性理解为类的专属的方法和属性，它不再是某个具体的对象的方法和属性，它是所有对象所共有的，因为它是"类的属性和方法",既然如此，那你也可以不用实例化对象，直接使用类名来使用static修饰的属性或者方法

   注意事项：

   1. 静态变量只能写在方法外面，不能写在方法体中
   2. 静态方法中不能使用this调用其他的非静态方法或者非静态属性。因为就像我刚才所说，静态方法的是属于类中的，而非对象，不用实例化就可以使用，但是this指向当前对象。。。。。不知道怎么说，反正就是this指向的问题。

3. static修饰的代码块：

   static{
   内容
   }

   写在方法外边的代码块，在类加载时执行该代码块且仅仅执行一次（比构造函数早，构造函数在实例化时才执行）。

   用途:常用来做初始化操作

4. 快捷键操作

   1. Eclipse中的生成构造函数的快捷键：Shift+Alt+S键+O键
   2. Idea中的快捷键:Alt+insert

封装

概念：隐藏内部实现细节，对外提供接口

1. 意义：

   1. 避免非法数据（可以对setter方法进行流程控制）使数据更加安全。
   2. 增加代码的重用性

2. 封装是如何实现的：

   1. 改变修饰符，所以修饰符的种类有哪些呢（将public改为private 或者 protected）
      • public(公有的)
      • private(私有的)
      • protected(受保护的)
      • friendly(默认)
        封装的原理就涉及到了一个访问权限的问题
        访问权限：public>protected>friendly>private

   访问范围	public	protected	private	friendly
   同一个类	√	√	√	√
   同一包中的其他类	√	√	×	√
   不同包中的子类	√	√	×	×
   不同包中的非子类	√	x	×	×

   2. 设置get/set方法（根据需求 对它加入条件判读）（这个get&set方法就是对外提供的接口）

继承

一、继承

1. 概念:继承是类与类之间的关系，被继承的那一方，可以使用基类的方法和属性,Java中只能单继承（即一个子类只能继承自一个父类）继承要满足 is-a的关系，例如:熊猫是一只哺乳动物；那么熊猫不仅有哺乳动物的特性还有一些特有的属性和行为；假如有多个类，它们有很多类似的地方，那我们就可以将这些共性抽离成一个父类，然后再让他们继承这个父类;

2. 语法,如下面代码所示，在需要继承的类后面加extends关键字再在关键字后面加入需要继承的类名

package cn.Sukura.www;
class Animals{
public String name;
public Animals(String name) {
  this.name = name;
}
public void sayHi() {
  System.out.printf("My name is %s\n",this.name);
}
}
class Pandas extends Animals{
public Pandas(String name) {
  //super()必须写在第一行
  super(name);
}
}
public class Test {
   public static void main(String[] args) {
       Pandas p = new Pandas("荣荣");
       p.sayHi();
   }
}

3. 哪些不能被继承

• 被final(最终的)修饰的类
• 不能继承父类的构造方法
• 不能继承被private修饰的方法或属性
• 不能继承在不同包下的父类中使用默认修饰符friendly的修饰的属性和方法（上面那条和这条其实就是设计一个访问权限的问题）

4. super关键字

   super()调用父类的构造方法，其实和this的使用是一样的，只不过super是调用关于父类的一切,super.Method()调用父类方法，super.attribute调用父类属性，在子类构造中调用super()时，super()必须写在第一行，不然不能通过编译

5. 实例化子类对象的执行过程:

   父类的静态成员,静态代码块 --> 子类的静态成员，静态代码块 -->父类属性 -->父类构造 -->子类属性 -->子类构造 -->实例化完成

二、重写

1. 概念：是指子类继承自父类，写一个和父类中方法名和参数相同的方法，子类中的该方法会覆盖父类的方法。(发生在继承当中)

2. 好处，可以子类根据不同的需要来实现不同的行为，父类只用来提供一个模板

3. 注意事项:

   • 继承是重写的大前提，没有继承就没有重写

   • 方法名和参数列表完全一致才叫做重写

   • 子类方法的访问修饰符必须大于或者等于父类方法的访问修饰符

• 子类方法的返回值必须与父类的返回值相关（返回基本数据类型时子类必须与父类完全一样，返回引用数据类型时，子类的返回值类型与父类的返回值类型相同，或是父类的返回值类型的子类）

4. 注解：以@开头的称为注解,@Override是重写的注解，表示该方法是重写方法,如果该方法不满足重写规则，使用该注解时就会报错。

三、抽象类

1. 什么是抽象类:使用abstract修饰类是抽象类，语法如下:

   public abstract class 类名{
       public void sayHi(){
           //这是一个正经的方法
       }
       public abstract void sayLove();//这是一个抽象方法
   }
   

2. 注意事项:

   • 抽象类不能被实例化，它主要的目的就是为了给子类做模板的！
   • abstract关键字不能和final或static一起出现（他们有冲突）
   • 用abstract修饰的方法是抽象方法，它没有方法体，抽象方法必须被子类实现，除非子类也是一个抽象类
   • 抽象方法必须写在抽象类中，但抽象类不止有抽象方法

3. abstract关键字 和 final关键字的异同

   • abstract可以修饰方法和类 ** final可以修饰类，方法，属性**
     • abstract修饰类时 该类不能被实例化，但是可以被子类继承(设计出来就是用来继承的)
     • final修饰类时 该类为最终类,不能被继承
     • abstract修饰方法时 该方法必须被子类实现除非子类也是一个抽象类，该方法不能有方法体!
     • final修饰方法时为最终方法，不能被重写
     • final修饰属性时，表示常量，必须赋初始值，并且一旦赋值就不能在修改

多态

接口

1. 接口的概念:Java中的接口是一个全部由抽象方法组成的集合,使用interface关键字来声明一个接口,接口里面只能有抽象方法和常量,实际上，它就是提供了一种规范，表示一种能力，增强了对于事物的扩展

2. 对于面向接口编程的理解: 要尽可能的使代码更加简介，复用性更高，我们就可以考虑,我们需要的是什么，我们需要知道它是什么吗？还是只需要知道它能做什么。可能我没说明白，还是写一段代码看看吧

   //首先根据业务需要 老师要教小朋友说普通话 
   class Teacher{
       public void teachToTalk(){
           //方法
       }
   }
   class Kids{
       String name;
       public void listenForClass{
           //假装里面有代码
       }
       public void readBookLoudly{
           //假装里面有代码
       }
   }
   //这时业务很简单，很容易就实现了
   

   //后来业务升级  老师的服务对象不仅仅只是小孩了 还有其他类型的学生 这时就会比较繁琐了，这时我们可以把他们的共性抽离出来写一个抽象类 也可以实现
   class abstract Person{
       String name;
       public abstract void listenForClass();
       public abstract void readBookLoudly();
   }
   class Kids extends Person{
       public void listenForClass{
           //假装里面有代码
       }
       public void readBookLoudly{
           //假装里面有代码
       }
   }
   class Adults extends Person{
       public void listenForClass{
           //假装里面有代码
       }
       public void readBookLoudly{
           //假装里面有代码
       }
   }
   class Teacher{
       public void teachToTalk(){
           //方法
       }
   }
   

   //现在你会发现只要服务对象是人都可以解决 业务继续升级  这时老师又需要服务动物 但是动物的技能和前面的不匹配了 而且也不可能实现多种动物，这时你会想到你关注的到底是什么，是他们是谁？还是他们能做什么？
   public interface ListenAndRead{
       public void listen();
       public void recite();
   }
   abstract class Person implements ListenAndRead{
   }
   class Child extends Person{//儿童
       public void listen(){}//听课
       public void recite(){}//朗读
   }
   class Student extends Person{
       public void listen(){}//听课
       public void recite(){}//朗读
   }
   class Foreigner extends Person{
       public void listen(){}
       public void recite(){}
   }
   class Parrot implements ListenAndRead{//鹦鹉
       public void listen(){}
       public void recite(){}
   }
   class Teacher{
       public void teach(ListenAndReciteAble lar){}
   }
   

   引用: 要让一个依赖方达到最大的兼容性或扩展性，就要让依赖的对象类型尽量宽泛，当然(为什么不用Object)Object是最宽泛的，但是这就不明确了，而且不能保证依赖方的需要。这是就要跳出一些定式，我需要什么的是什么？还是我需要的是他们会什么？这就变成了面向接口编程。

3. 接口的语法

   定义接口:

   访问修饰符 interface关键字 接口的名字{
       
   }
   例如:
   public interface Call{
       void CallByWechat();
   }
   

   实现接口:

   • 父类和子类的关系叫做继承
   • 接口与实现类的关系叫做实现
   • 使用implements关键字来实现接口，可以实现很多接口(实现多继承)

   class Phone implements Call,Play{
       public void CallByWechat(){
           //实现
       }
   }
   

4. 接口的特点

   • 不能被实例化

   • 接口中的方法都是抽象方法访问修饰符默认为public 且必须是public

   • 接口可以有属性，但他们只能是公有的静态常量(public static final)写于不写都如此

   • 实现类必须重写父接口的所有方法

   • 接口可以继承接口

5. 接口与抽象类的异同点

异常

1. 概念: 程序在运行中出现预料之外的错误

2. 在Java中一般产生异常的情况有以下三种:

   • Java内部发生错误产生异常，Java虚拟机产生的异常
   • 编写代码错误产生的异常,如空指针异常，数组越界等异常,这种异常称为未检查异常
   • 通过throw语句手动抛出的异常

3. 异常的类型

   graph TD A(Throwable)-->B1(Error错误) A -->B2(Exception异常) B2 -->C1(运行时异常即非检查异常) B2 -->C2(非运行时异常即检查异常)

运行时异常：都是RuntimeException 类及其子类异常，例如空指针异常、数组越界异常等,这些异常是不检查异常,程序可以选择捕获处理，或者不处理，这些异常一般都是程序的逻辑引起的

检查异常:指运行时异常以外的类型,在类型上都属于Exception及其子类,该类异常必须处理，如果不处理就无法编译通过,常见的有IOException、ClassNotFoundException 等还有用户自己抛出的异常,如果你不处理的话肯定是会报红的对不对

4. 常见的异常

   异常类型	说明
   Exception	异常类，它是所有异常类的顶级父类。
   RuntimeException	运行时异常
   ArithmeticException	除0异常，除数不能为0
   ArrayIndexOutOfBoundsException	数组下标越界
   NullPointerExceptio	空指针异常
   ClassNotFoundException	不能加载所需要的类
   ClassCastException	对象强制类型转换错误

5. 处理的方式，如下代码演示

   捕获处理方式

   try{    //可能出现异常的代码块}catch(异常类型 对象名字){    //出现异常时处理方式}catch(异常类型 对象名字){    //出现异常时处理方式}finally{    //最后执行这个 无论如何都会执行 除非System.exit()}
   

   捕获异常代码一般根据异常类型从小到大捕获 因为程序出现异常时只会进入第一个符合条件的代码块中

   还可以通过抛出的方式处理异常

   //将异常往外抛出，不再用本类中的try-catch来处理，让调用该方法的那一方来处理public class Test {    //throws 往外抛出异常  throw 人为制造一个异常	public void playing() throws Exception {//在方法名的小括号后面、大括号前面加上 throws 异常类名1,异常类名2		throw new Exception("作业没写完，还想玩?");	}	public static void main(String[] args) {		Test t = new Test();		try {			t.playing();		} catch (Exception e) {			e.printStackTrace();		}	}}
   

   6. finally、finalize、final的区别

   finally	finalize	final的区别
   修饰类时，此类不能被继承，修饰方法时，该方法不能被重写,修饰属性时，属性的值不能被更改而且一定要赋值	java中的垃圾回收方法，可以清理内存未使用的对象该方法不需要调用，因为java会自动检测并清理内存，简称为GC	异常处理的一部分 表示一定执行 除非遇到上面讲的那个语句

集合框架

1. 为什么要使用集合框架?
   数组的弊端：类型必须相同、长度是固定的，如果一组数据在程序运行时并不能确定长度，那就不能再使用数组了
   相对于数组，集合框架不限类型，并且长度可变，运用更加灵活。
   

现学部分的重点是标红部分

Collection和Map是java.util包下的两个集合上级接口

• Collection：存储单个对象的集合 特点:无序(有序、无序是指在进行插入操作时，插入位置的顺序性
  先插的位置在前，后插的位置在后，则为有序，反之无序)，不唯一

  如图所示，它拥有三个子类型集合List、Set 和 Queue(重点是List)

  • List :有序，不唯一

    ​ 常用的实现类:

    	1.  `ArrayList` :以`数组`的方式存储,**查询的效率高，插入和删除的效率低**	2.  `LinkedList`：以`链表`的方式，**插入和删除的效率高，查询的效率低**，和`ArrayList`相反
    

  List常用方法	功能
  add(obj) /add(int index,obj o)	添加对象/在指定位置插入
  remove(obj (这是Collection提供的方法))/remove(int index)（这是List提供的方法）	按对象删除/按下标删除
  get(int index)	获取对象
  size()	获取集合的长度
  contains()	查看集合中是否包含某对象

  前三个方法LinkedList有扩展的方法如addFirst(),addLast();(功能就不解释了，顾名思义，其余两个以此类推)

  • Set：无序、唯一，典型的实现类有：
    HashSet：以哈希表的形式存储
    TreeSet：以树形表的形式存储

• Map:存储键(key,value)值对的集合 键唯一，值不唯一。

Map典型的实现类
- HashMap: 允许插入空值,效率高,线程不安全
- Hashtable :不允许插入空值,效率低，但线程安全
- TreeMap

集合的遍历

1. java中的foreach

for(类名 对象名:集合){    }//例如class Student{	String name;	int age;	public Student(String name, int age) {		this.name = name;		this.age = age;	}	}public class Test {	public static void main(String[] args) {				List l = new ArrayList();		l.add(new Student("Yuan",19));		l.add(new Student("He",19));		for(Object s:l) {			Student stu = (Student)s;			System.out.println(stu.name);		}	}}

2. 使用iterator迭代器

   • 如何获得iterator迭代器?

     通过Collection提供的方法Iterator<e> Iterator()方法来得到一个迭代器

   • Iterator迭代器有哪些方法

   方法	功能
   boolean hasNext()	判断是否还有下一个元素,如果有返回true,没有返回false
   E next()	获得下一个元素

List list = new ArrayList() {
	{
		this.add(new Student("张三",20));
		this.add(new Student("李四",20));
	}
};
Iterator iter= list.iterator();
while(iter.hasNext()) {
	Student s = (Student)iter.next();
	String name = s.name;
	System.out.println(name);
}

3. 使用for循环 + Iterator迭代器

List list = new ArrayList() {
	{
		this.add(new Student("张三",20));
		this.add(new Student("李四",20));
	}
};	
for(Iterator iter = list.iterator();iter.hasNext();) {
	Student s = (Student)iter.next();
	String name = s.name;
	System.out.println(name);
}
//另外 单纯的用for循环也是可以遍历的 因为List是有序的

泛型

1. 为什么要用泛型:先注意集合的特点：集合长度可变，并且可以放任意的引用数据类型,存储的数据类型也可以不一样假如我有一个这样的需求,我需要获取全班所有人的姓名，但有个别人捣乱,把名字写成电话号码，导致我后面的代码出错,这种时候,就需要使用到泛型了,如果没按照我的规定来存放数据就会报错,等于是将运行时期会发生的异常提前到编译时期了。所以可见泛型是一种安全机制,一种规范,它和接口一样在制定规则。

2. 如何理解泛型？大家上学的时候都写过作文吧,考试的时候作文上面的要求经常是题材不限,但是一旦你确认题材了,你就不能再写其他题材的作文了，泛型也是如此，本质上泛型是一个变量，它是需要我们赋值的。

//例如
List<student> names = new ArrayList<student> names();
//这时我如果给他存放其他的数据类型就会出错  而且我们在取元素的时候不需要强制类型转换

还有泛型类泛型方法之类的没太多时间去补充，到时候补充和完善。