Java学习笔记

MyEclipse: https://www.cnblogs.com/lqflzt14/p/10194918.html
myeclipse破解之后不能创建web项目https://zhidao.baidu.com/question/1304297309589043339.html

封装

封装就是隐藏实现细节，仅对外提供访问接口。
封装的类型有：属性封装，方法的封装，类的封装，组件的封装，模块化封装，系统性封装

封装的好处

1，模块化
2，信息隐藏
3，代码重用
4，插件化易于调试
5，安全

缺点：影响执行效率
访问权限修饰符
访问权限 类 包 子类 其他包

public     ∨   ∨   ∨     ∨

protect    ∨   ∨   ∨     ×

default    ∨   ∨   ×     ×

private    ∨   ×   ×     ×

private 关键字:访问权限修饰符
定义方法来调用参数

构造方法（构造器）

1. 构造方法久时类构造对象时调用的方法，用于对象的初始化工作
2. 构造方法是实例化一个类的对象时，最先调用的方法。
   构造方法的定义：
3. 构造方法是在类中定义的，构造方法的定义格式：方法名称与类名相同，无返回值类型的声明。对象的实例化语法：
   Test test=new Test();//带括号表示调用了方法，此时调用的方法就是构造方法。
4. 一个类中有多个构造方法就叫构造方法的重载（overload)
5. 在调用其他构造方法时this语句需要在方法内第一句
6. 有其他构造方法时，一般都保留默认构造方法
7. 每一个类都有默认的无参的构造方法
8. 如果类中有显示的构造方法，默认的构造方法无效
9. 如果有显示的构造方法，还想保留默认构造方法，需要重写默认方法
10. 一般来说需要保留默认的构造方法。
11. 构造方法私有化，目的时为了保证该类只有一个对象时。工具类（没有属性，只有行为）

this关键字

变量 静态变量（全局变量）

1. 调用类中的属性
2. 调用类中的方法或构造方法
3. 表示当前对象

Static（静态）关键字

1. 静态变量或方法不属于对象，依赖类
2. 静态变量是全局变量，生命周期从类被加载一直到程序结束
3. 静态变量只存一份，在静态方法区中存储
4. 静态变量为本类所有对象共享一份
5. 建议不要使用对象名去调用静态数据，直接使用类名调用
6. static修饰一个方法，那么该方法属于类，不属于对象，直接使用类名调用，对象不能进行调用
7. 静态方法不能访问非静态属性和方法，只能访问被static修饰的变量和方法
8. 不能以任何方式引用this或者super
9. 当所有对象有共同的属性或方法，我们可以定义为静态的

代码块

1. 普通代码块（在方法中写的代码块）
2. 构造代码块（在创建对象时被调用，优于构造方法执行）
3. 静态代码块 （在类中使用static声明的代码块，优于构造代码块，在创建对象时被调用，只会执行一次，通常会用来初始化只调用一次的数据）
   重点使用的时静态代码块

单例设计模式

1. 构造方法私有化
2. 声明一个本类对象
3. 给外部提供一个静态方法获取对象实例

实现方式
4. 懒汉式：在第一次调用getInstance方法时，对象被创建，到程序结束后释放（占用内存时间短，效率低）
5. 饿汉式：在类被加载后，对象被创建，到程序结束后释放（占用内存时间长，效率高）

继承

从已有的类创建新类的过程

1. 继承是面向对象三大特征之一
2. 被继承的类成为父类（超类），继承父类的类被称为子类（派生类）
3. 继承是指一个对象直接使用另一对象的属性和方法
4. 通过继承可以实现代码重用
5. 继承一个父类，只能继承非私有的数据（属性和方法）
6. protected 访问权限修饰符，在继承关系时使用，在父类中使用protected修饰的属性或方法可以被子类继承
7. 创建子类对象时，父类的构造方法也会被调用，是因为子类要使用到父类的数据，那么就要通过父类的构造方法来初始化数据
8. 子类创建对象时会调用父类的默认构造方法
9. java只能单继承，允许多层继承即父类的父类
10. 创建对象会调用父类的构造方法，调用构造方法不一定就是创建该类对象
11. 实例化子类对象，会先调用父类的构造方法，如果父类中没有默认的构造方法，那么子类必须显示的通过super（）来调用父类的带参数的构造方法，super也只能在子类构造方法的第一句

继承的限制约定

1. java只能实现单继承，也就是一个类只能有一个父类
2. 允许多层继承，即一个子类可以有一个父类，一个父类还可以有其他父类。
3. 继承只能继承非私有的属性和方法
4. 构造方法不能被继承

语法：[访问权限] class 子类名 extends 父类名{ 类体定义}
example:
public class Animal{
private String name;
private String sex;
public void eat(){
System.out.println(“Eating …”);
}
public class Dog extends Animal{}

继承总结

优点：

• 提高代码复用性
• 提高代码的维护性
• 让类与类之间产生关系，是多态的前提
  缺点：
  增强了类与类之间的耦合性
  开发原则：高内聚，低耦合

方法重写（overriding method）

1. 发生在子父类中，方法重写的两个方法返回值，方法名，参数列表必须完全一致（子类重写父类的方法）
2. 子类抛出的异常不能超过父类相应方法抛出的异常（子类异常不能大于父类异常）
3. 子类方法的访问级别不能低于父类相应方法的访问级别
4. 父类方法中的方法若使用private，static ，final修饰符修饰，该元素不能被重写

为什么要重写方法？或者方法重写的目的是什么？

若子类从父类中继承过来的方法，不能满足子类特有的需求时，子类就需要重写父类中相应的方法，方法的重写也是程序扩展的体现

super关键字

1. 可以调用父类中的属性，可以从父类实例处获得信息
2. 使用super（）调用父类中的方法，可以委托父类对象帮助完成某件事
3. 使用super（）调用父类中的构造方法super() 必须在子类构造方法的第一条语句，调用父类中镶银的构造方法，若不显示的写出来，默认调用父类的无参构造方法

this表示当前对象
super表示调用父类的属性,方法，构造方法

final关键字

1. 使用final关键字声明一个常量
   修饰属性或者修饰局部变量（最终变量），也称为常量(常量名建议使用全大写：PERSON_NUM
2. 使用final关键字声明一个方法
   该方法为最终方法，且只能被子类继承，但是不能被子类重写
3. 使用final关键字声明一个类
   该类就转变为最终类，没有子类的类，final修饰的类无法被继承
4. 在方法参数中使用final，在该方法内部不能修改参数的值，（在内部类中详解)

抽象类abstract

1. 很多具有相 同特征和行为的对象可以抽象为一个类，很多具有相同特征和行为的类可以抽象为一个抽象类
2. 使用abstract关键字声明的类称为抽象类

抽象类的规则

1. 抽象类可以没有抽象方法，有抽象方法的类必须是抽象类。
2. 非抽象类继承抽象类必须实现所有抽象方法。
3. 抽象类可以继承抽象类，可以不实现父类抽象方法
4. 抽象类可以有方法实现和属性
5. 抽象类不能被实例化
6. 抽象类不能声明final
7. 抽象类可以有构造方法

接口（interface）

接口使用规则：

1. 定义一个接口，使用interface关键字
2. 在一个接口中，只能定义常量，抽象方法，jdk1.8后可以定义默认的实现方法
3. 接口可以继承多个接口 extends xx,xx,xx
4. 一个具体类实现接口使用implements关键字
5. 一个类可以实现多个接口
6. 抽象类实现接口可以不实现接口的方法
7. 在接口中定义的方法没有声明访问修饰符，默认为public
8. 接口不能有构造方法

面向对象设计原则

1. 对修改关闭，对扩展开放
2. 面向接口编程

格式：
interface Name{
全局常量；
抽象方法；（默认方法修饰符是public abstract）

多态

多态性可以分为两类，
1.方法的重载与重写
2.对象的多态性

用父类的引用指向子类对象（用大的类型去接受小的类型，向上转型，自动转换）
Animals a1=new Dog();

结论：
在编程时针对抽象类型的编写代码，成为面向对象编程（或者面向接口编程）父类通 Animals d1 = new Dog(“Dog”);
// d1.eat();
Animals c1 = new Cat(“Cat”);
// c1.eat();
eat(d1);

}
public static void eat(Animals a){
    a.eat();
    System.out.println(a.getName()+"is eating");
}

面向抽象（面向接口）编程

对象的多态性：

对象的多态性是从继承关系中的多个类而来
向上转型 将子类实例转为父类引用
格式: 父类 父类对象 =子类实例 → 自动转换
以基本数据类型操作为例: int i=“A”;
因为char的容量比int小,所以可以自动完成

向下转型 将父类实例转为子类实例
格式:子类 子类对象=(子类) 父类实例
以基本数据类型操作为例 char c=(char)97;
因为整型是四个字节比char两个字节大,所以需要强制完成

多态性小结

1. 方法的重载与重写就是方法的多态性表现
2. 多个子类就是父类中的多种形态
3. 父类引用可以指向子类对象,自动转换
4. 子类对象指向父类引用需要强制抓换(类型不对,会报异常)
5. 在实际开发中尽量使用父类引用(更利于扩展)

instanceof关键字

instanceof 用于检查对象是否为指定类型,通常在把父类引用强制转换为子类引用时使用,以避免发生类型转换异常

语法格式如下:
对象 instanceof 类型 返回Boolean值
ex:
Animal a1=new Dog();
if(a1 instanceof Animal){
}

父类设计法则
1 父类通常都设计为抽象类或接口,有限考虑接口,如接口不能满足才考虑抽象类
2 一个具体的类尽可能不去继承另一个具体类,这样的好处是无须检查对象是否为父类的对象