面向对象（重点难点）
面向对象和面向过程
都是编程思想
面向过程注重过程，步骤，怎么做 执行者
面向对象注重对象，谁来做 指挥者
面向对象学习
1、类与对象
（1）类与对象的概念
（2）类与对象的关系
（3）如何设计类，类的成员
（4）如何创建对象
2、面向对象的三个基本特征和高级特性
基本特性
封装 继承 多态
高级特性
枚举 接口 抽象 泛型 注解 可变参数 自动装箱与拆箱 foreach lambda表达式
相关的关键字和API
关键字： class new this super 权限修饰符（public protected private 缺省） ......
API: 集合 异常 IO 网络编程 线程 ......
类与对象
类与对象的概念
类：对一类具有相同特征的事物的抽象描述
对象：类的实例，是具体的个体
类与对象的关系
类是对象的设计图，创建的模板
对象是类的实例，是一个具体的个体
类的设计、成员
属性：
属性的特点： 声明的位置在类中方法外 保存的位置 static在方法区 非static在堆中 默认值 byte,short,int,long是0，float,double是0.0，boolean是false，char是\u0000，引用数据类型都是null 作用域在整个类中 ，生命周期 随着对象的创建而创建，到垃圾回收为止
属性的声明格式：[修饰符] 数据类型 属性名 【=显式值】; 修饰符 private 私有化
构造器：
构造器的作用： 和new一起创建对象 为属性赋值
如何声明：
无参
[修饰符] 类名(){
}
有参
[修饰符] 类名(形参列表){
}
特点：
（1）构造器名与类名必须相同
（2）构造器没有返回值
（3）构造器可以重载
（4）如果一个类没有声明过构造器，编译器将默认添加一个无参构造如果这个类声明了构造器，编译器将不再自动添加无参构造
如何调用：
和new一起 new 构造器() new 构造器(实参列表)
在本类的其他构造器中或子类的构造器中：
在本类的其他构造器中：this()或this(实参列表)
在子类的构造器中：super()或super(实参列表)
方法：
有参无返回值 无参无返回值 有参又返回值 无参无返回值
内部类：
什么情况下使用内部类：
（1）当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类
（2）内部类可以访问外部类的所有的成员，包括私有的
静态内部类
//格式
[修饰符] class 外部类{
[修饰符] static class 内部类{
}
修饰符的问题：
（1）权限修饰符 必须有
（2）static 必须有
（3）final（极少） 可以 表示不能被继承
（4）abstract（极少）可以 表示可以包含抽象方法，需要子类继承
静态内部类的成员：所有都可以，包括静态的
使用问题：
（1）在静态内部类中使用外部类的成员
只能使用外部类的静态成员
（2）在外部类中使用静态内部类
都可以
（3）在外部类的外面，其他类中
（1）用静态内部类的静态成员
外部类名.内部类名.静态成员
（2）用静态内部类的非静态成员
需要静态内部类的对象
外部类名.内部类 变量 = new 外部类名.内部类();变量.成员....
非静态内部类，通常称为成员内部类：
//格式
[修饰符] class 外部类{
[修饰符] class 内部类{
}
修饰符的问题：
（1）权限修饰符 必须有
（2）static 没有
（3）final（极少） 可以 表示不能被继承
（4）abstract（极少）可以 表示可以包含抽象方法，需要子类继承
非静态内部类的成员：除了静态成员，其他都可以
使用问题：
（1）在非静态成员内部类中使用外部类的成员
都可以
（2）在外部类中使用非静态成员内部类
在外部类的静态成员中不能使用非静态成员内部类
静态不能用非静态 原因，静态的成员先加载，非静态只有创建对象才有
（3）在外部类的外面使用非静态成员内部类
依赖于外部类的对象
形式一
（1）先创建外部类的对象
外部类 out = new 外部类();
（2）通过外部类的对象创建内部类的对象
外部类.内部类 in = out.new 内部类();
（3）通过内部类对象调用它的成员
in.成员
形式二
（1）在外部类中提供一个方法，用来返回内部类的对象
class 外部类{
class 内部类{
}
public 内部类 getInnerInstance(){
return new 内部类();
}
（2）创建外部类的对象
外部类 out = new 外部类();
（3）通过外部类的对象，获取内部类的对象
外部类.内部类 in = out.getInnerInstance();
（4）通过内部类对象调用它的成员
in.成员
面试题：
//如何继承非静态成员的内部类
class Outer{
class Inner{
}
}
class Other extends Outer.Inner{
Other(Outer out){
out.super();
}
}
有名字的局部内部类，通常称为局部内部类
//格式
[修饰符] class 外部类{
[修饰符] 返回值类型 方法名([形参列表]){
[修饰符] class 内部类{
}
}
修饰符的问题：
（1）权限修饰符 都不行
（2）static 没有
（3）final（极少） 可以 表示不能被继承
（4）abstract（极少）可以 表示可以包含抽象方法，需要子类继承
有名字的局部内部类的成员 除了静态成员其他都可以
使用：
（1）在内部类中使用外部类的成员
受所在方法的约束，如果所在方法是静态的，那么只能使用外部类的静态成员，如果所在方法是非静态的，那么都可以使用
（2）在内部类中使用外部类的局部变量
必须是final修饰
（3）在外部类中使用内部类
只能在声明它的方法中使用，而且在声明之后使用
和局部变量的作用域一样
（4）在外部类的外面
不可以
（5）在外部类的其他方法中
不可以
匿名内部类：
//格式
new 父类/父接口(){
方法
}
修饰符 一个都没有
匿名内部类的成员
除了非静态的都可以，但是一般很少自定义方法等成员，它的成员都是重写父类的，父接口的方法
匿名内部类的特点
（1）声明类和创建对象同时进行， 只有一个对象
public static void main(String[] args) {
//Object的一个子类对象
new Object(){
public void test(){
System.out.println(this.getClass());
}
}.test();
//Object的另一个子类对象
new Object(){
public void test(){
System.out.println(this.getClass());
}
}.test();
}
（2）子类一定会调用父类的构造器
class MyClass{
private String info;
MyClass(String info){
this.info = info;
}
}
//创建一个MyClass的子类对象，使用匿名内部类
MyClass m = new MyClass("参数"){
};
匿名内部类的使用形式
//形式一
//匿名内部类的匿名对象直接调用方法
new Object(){
public void test(){
System.out.println(this.getClass());
}
}.test();
//形式二
//与父类或父接口直接构成多态引用
class MyClass{
public void test(){
System.out.println("父类的测试方法");
}
}
MyClass m = new MyClass(){
public void test(){
System.out.println("重写");
}
};
m.test();
//形式三
//匿名内部类的匿名对象作为实参
MyClass[] arr = new MyClass[5];
Arrays.sort(arr, new Comparator(){
@Override
public int compare(Object o1, Object o2) {
return 0;
}
});
使用其他要求
（1）在内部类中使用外部类的成员
受所在方法的约束，如果所在方法是静态的，那么只能使用外部类的静态成员，如果所在方法是非静态的，那么都可以使用
（2）在内部类中使用外部类的局部变量
必须是final修饰
代码块（按位置分）：
在类中方法外
有static修饰的：静态代码块
//语法结构
class 类{
static{
静态代码块
}
}
特点
随着类的加载并初始时而执行，而且一个类的静态代码块只执行一次
而且父类的静态代码块优先于子类的静态代码块
静态代码块肯定优先于构造块和构造器
作用
为静态变量（类变量）初始化（赋值）
没有static修饰的：非静态代码块，构造块
//语法结构
class 类{
{
静态代码块
}
}
特点
每次创建对象时调用，而且先于构造器调用
作用
为实例变量初始化（赋值），一般是多个构造器中重复的代码提取到构造块
在方法中：局部代码块（了解）
标签：部类,内部,静态,成员,修饰符,面向对象,new From： https://www.cnblogs.com/woniupa/p/17131483.html