成员变量和局部变量的区别？
1.在类中的位置不同
成员变量：在类中方法外
局部变量：在方法定义中或者方法声明上
2.在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
3.生命周期不同
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
4,初始化值不同
成员变量：有默认初始化值
局部变量:没有默认初始化值，必须定义，赋值，然后才能使用
注意事项：
局部变量名称和成员变量名称可以一样，在方法中使用的时候，采用的是就近原则
形式参数的问题：
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
匿名对象的应用场景：
new Student().show()；
1.调用方法，仅仅只调用一次的时候，那么这种匿名调用有什么好处吗？
有，匿名对象调用完毕就是垃圾，可以被垃圾回收器回收
2.匿名对象可以作为实际参数传递
封装概述：
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处;隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高了代码的安全性
原则：
将不需要对外提供的内容都隐藏起来
把属性隐藏，提供公共的方法对其访问
private关键字：
是一个权限修饰符
可以修饰成员（成员变量和成员方法）
被private修饰的成员，只能在本类中才能访问。
private最常见的应用
把成员变量用private修饰，提供对应的getXXX（）setXXX（）方法
构造方法的注意事项：
1.如果我们没有给出构造方法，系统将自动提供一个无参构造方法
2.如果我们给出了构造方法，系统将不再提供默认的无参构造方法
给成员变量赋值有两种方法：
1.利用setXXX（）方法赋值，这种方式调用的一般是无参的构造函数，利用 对象名.setXXX("林青霞")；
2.利用带有参数的构造方法赋值 通过调用有参构造函数，在创建对象的时候，直接赋值
class Student{
private String name = "林青霞";
private int age = 27；
public Student（）{
name = "刘意"；
age = 30；
}
}
class StudentDemo{
public static void main(String [] args){
Student s = new Student();
}
}
Student s = new Student();做了哪些事情
1.把Student.Class文件加载到内存
2.在栈内存给s变量开辟一个空间
3.在堆内存为学生对象申请一个空间
4.给成员变量进行默认初始化 null 0
5.给成员变量进行显示初始化 林青霞 27
6.通过构造方法给成员变量进行初始化 刘意 30
7.数据初始化完毕，然后把堆内存的地址值赋值给栈内存的S变量
变量什么时候定义为成员变量;
如果这个变量是用来描述这个类的信息的，那么，该变量就应该定义为成员变量
变量到底定义在哪里好？
变量的范围越小越好，因为能及时被回收。
static的特点（它可以修饰成员变量，也可以修饰成员方法）
1.随着类的加载而加载
2.优先于对象存在（不用创建对象，它修饰的成员就能使用）
3.被类的所以对象共享
4.可以通过类名调用
static关键字的注意事项;
1.在静态方法中是没有this关键字的
如何理解呢？
静态是随着类的加载而加载，this是随着对象的创建而存在
2.静态方法只能访问静态的成员变量和静态的成员方法
静态方法：
无论是访问成员变量还是都成员方法，都必须是静态的
非静态方法：
访问静态和非静态都可以
简单记：静态只能访问静态
静态变量和成员变量的区别：
所属不同
静态变量直属于类，所以也成为类变量
成员变量属于对象，所以也称为实例变量
内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存
内存出现时间不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失
调用不可
静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用
main方法的讲解：
public static void main(String [] args)
public :公共的，访问权限最大，由于main方法是被jvm调用，所以权限要大
static：静态的，不需要创建对象，通过类名就可以，方便jvm的调用
void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用，所以返回内容给jvm没有意义
main：是一个常见的方法入口，虚拟机认识的名字
String[] args:这是一个字符串数组，值去哪里了？
这个东西到底有什么用？怎么给值？
这个东西早期是为了接收键盘入录的数据的，后面才有了Scanner
格式是：
java MainDemo hello world java
如何制造一个说明书呢？
1.写一个工具类
2.对这个类加入文档注释
3.用工具解析文档注释
4.格式 javadoc -d 目录 -author -version ArrayTool.java
目录：就可以写一个文件夹的路径
制作帮助文档出错：
找不到可以文档化的公共或受保护的类：告诉我们类的权限不够
如何查看api文档
1.打开帮助文档
2.点击显示，找到索引，看到输入框
3.知道你要找谁？以Scanner为例
4.在输入框里面输入Scanner，然后回车
5.看包
java.lang包下的类不需要导入，其他的全部要导入
要导入：
java.util.Scanner
6.再简单的看看类的解释和说明，别忘了看看该类的版本
7.看类的结构
成员变量 字段摘要
构造方法 构造方法摘要
成员方法 方法摘要
8.构造方法
1.有构造方法 就创建对象
2.没有构造方法 成员可能都是静态的
9.看成员方法
1.左边
是否静态：如果静态，可以通过类名调用
返回值类型：人家返回什么，你就用什么接收
2.右边
看方法名：方法名称不要写错
参考列表：人家要什么，你就给什么，人家要几个，你就给几个
代码块：在java中，使用{}括起来的代码被称为代码块
根据其位置和声明的不同，可以分为：
局部代码块：局部位置，用于限定变量的生命周期
构造代码块：在类的成员位置，用{}括起来的代码，每次调用构造方法执行前，都会先执行构造代码块
静态代码块：在类的成员位置，用{}括起来的代码，只不过它用了static修饰
作用：一般是对类进行初始化
面试题：静态代码块，构造代码块，和构造方法的执行顺序？
静态代码块-》构造代码块-》构造方法
静态代码块：只执行一次
构造代码块：每次调用构造方法都执行
继承概述：
把多个类中相同的内容给提取出来定义到一个类中
如何实现继承呢？
java提供了关键字：extends
格式：
class 子类名 extends 父类 {}
好处：
1.提高了代码的复用性
2.提高了代码的维护性
3.让类与类之间产生了关系，是多态的前提。
类与类产生了关系，其实也是继承的一个弊端：类的耦合性增强了
开发的原则：低耦合，高内聚
耦合：类与类的关系
内聚：就是自己完成某件事情的能力
java只支持单继承，不支持多继承
一个类只能有一个父类，不可以有多个父类
java支持多层继承（继承体系），
继承的注意事项：
1.子类只能继承父类所有非私有的成员（成员方法和成员变量）
2.子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法
3.不要为了部分功能而去继承
class A{
public void show1(){}
public void show2(){}
}
class B{
public void show2(){}
public void show3(){}
}
我们发现B类中出现了和A类一样的show2（）方法，所以，我们采用继承
class B extendx A{
public void show3(){}
}
这样其实不好，因为这样你不但有了show2（），还多了show1（），有可能show1（）不是你想要的
那么我们什么时候考虑使用继承呢？
继承其实体现的是一种关系：is a
person
Student
Teacher
继承中成员变量的关系
1.子类中的成员变量和父类中的成员变量名称不一样，这个简单
2.子类中的成员变量和父类中的成员变量名称一样，这个怎么玩呢？
在子类方法中访问一个变量的查找顺序：
1.在子类方法的局部范围，有就使用
2.在子类的成员范围，有就使用
3.在父类的成员范围找，有就使用
4.如果还找不到，就报错
this和super的区别？
this代表本类对象的引用
super代表父类存储空间的标识（可以理解为父类引用，可以操作父类的成员）
怎么用呢？
1.调用成员变量
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
2.调用构造方法
this（...）调用本类的构造方法
super（...）调用父类的构造方法
3.调用成员方法
this.成员方法，调用本类的成员方法
super.成员方法，调用父类的成员方法
继承中构造方法的关系？
1.子类中所有的构造方法默认都会访问父类中空参数的构造方法
2.为什么呢？
因为子类会继承父类中的数据，可能还会使用父类的数据，
所以，子类初始化之前，一定要先完成父类数据的初始化。
注意：子类每一个构造方法的第一条语句默认都是：super();
如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢？如何解决呢？
会报错：
如何解决呢？
1.在父类中加一个无参构造方法
2.通过使用super关键字去显示调用父类的带参构造方法
3.子类通过this去调用本类的其他构造方法（前提是子类中其他的构造方法中，
一定要有一个区访问了父类的构造方法，否则父类数据就没有初始化）
注意事项：
this（...）或者super（...）必须是第一条语句
如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化（为什么呢？因为默认第一条语句会隐含调用父类的无参构造方法），所以必须放在第一条语句上。
继承中成员方法的关系：
1.子类中的方法和父类中的方法声明不一样，这个简单，直接调用
2.子类中的方法和父类中的方法声明一样，这个该怎么玩呢？
通过子类调用方法：
1.先找子类中，看有没有这个方法，有就使用
2.再看父类中，有没有这个方法，有就使用
3.如果没有就报错
方法重写:子类中出现了和父类中方法声明一模一样的方法
方法重载：在同一个类中出现的方法名一样，参数列表不同，与返回值无关
子类对象调用方法的时候：先找子类本身，再找父类
方法重写的应用：
当子类需要父类的功能，而功能主体子类有自己特有的内容时，
可以重写父类的方法，这样，既沿袭了父类的功能，又定义了子类特有的内容
方法重写的注意事项：
1.父类中私有方法不能被重写
因为父类私有方法根本就无法继承
2.子类重写父类方法时，访问权限不能更低
最好是一致
3.父类静态方法，子类也必须通过静态方法进行重写
其实这个算不上方法重写，但是现象确实如此
子类重写父类方法的时候，最好声明是一模一样的
方法重写和方法重载的区别？方法重载能改变返回值类型吗？
方法重写：
在子类中，出现和父类中一模一样的方法声明的现象
方法重载：
同一个类中，出现的方法名相同，参数列表不同的现象
方法重载能改变返回值类型，因为它和返回值类型无关
override：方法重写
overload：方法重载
由于继承中方法有一个现象：方法重写
所以，父类的功能，就会被子类给覆盖
有些时候，我们不想让子类去覆盖父类的功能，
这个时候，针对这种情况，java就提供了一个关键字：final
final：最终的意思。常见的是它可以修饰类，方法，变量
特点：
final可以修饰类，该类不能被继承
final可以修饰方法，该方法不能被重写
final可以修饰变量，该变了不能被重新赋值，因为这个变量其实是常量
常量：1.字面值常量 “hello”，10，true
2.自定义常量
final int x = 10；
注意，权限修饰符public，private等修饰局部变量是没有意义的，
因为局部方法本身就是封装的，谈不上要不要访问。
面试题：final修饰局部变量的问题
基本类型;基本类型的值不能发生改变
引用类型：引用类型的地址值不能发生改变，
但是，该对象的堆内存的值是可以改变的
多态：同一个对象，在不同时刻体现出来的不同状态
多态的前提：
1.要有继承关系
2.要有方法重写
3.要有父类引用指向子类对象
父 f = new 子（）；
多态中的成员访问特点：
1.成员变量
编译看左边，运行看左边
2.成员方法
编译看左边，运行看右边
3.构造方法
创建子类对象的时候，访问父类的构造方法，对对象的数据进行初始化
4.静态方法
编译看左边，运行看左边
静态和类相关，算不上重写，所以，访问还是左边的
由于成员方法存在方法重写，所以它运行看右边
多态的好处：
1.提高了代码的维护性（继承保证）
2.提高了代码的扩展性（多态保证）
多态的弊端：
不能使用子类的特有功能（因为在调用成员方法的时候，编译要看左边，一旦调用子类的特有功能，在父类中没有，就会编译失败）
但是我就是想使用子类的特有功能，行不行？
行
怎么用呢？
1.创建子类对象调用方法即可（可以，但是意味着要创建新的对象，浪费内存）
2.把父类的引用强制转换为子类的引用（向下转型）
对象间的转型问题：
向上转型：
Fu f = new Zi（）；
向下转型
Zi z = （Zi）f（）；//要求该f必须是能够转换为Zi的
抽象类的概述：
动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的
我们把一个不是具体的功能称为抽象功能，而一个类中如果有抽象功能，该类必须是抽象类
抽象类的特点;;
1, 抽象类和抽象方法必须用abstract关键字修饰
2.抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
3。抽象类不能实例化，因为它不是具体的
抽象类有构造方法，但是不能实例化，那么构造方法的作用是什么呢？
用于子类访问父类数据的初始化
4.抽象类的子类
1.如果不想重写抽象方法，那么该子类也必须是一个抽象类
2.如果重写了所有的抽象方法，这个时候子类是一个具体的类
抽象类的实例化其实是靠具体额子类实现的，也就是多态
Animal a = new Cat（）；
抽象类成员的特点
成员变量：既可以是变量，也可以是常量
构造方法：有，用于子类访问父类数据的初始化
成员方法：既可以是抽象的，也可以是非抽象的
抽象类成员方法的特性：
1.抽象方法 强制性要求子类做的事情
2.非抽象方法 子类继承的事情，提高了代码的复用性
一个类如果没有抽象方法，可不可以定义为抽象类，如果可以，有什么意义？
答，可以，作用就是不让创建对象呗
abstract不能和哪些关键字共存？
private,冲突,因为你加了private,子类怎么继承啊，都没有权限，而定义抽象类，就是要子类去实现的
final 就是终止，都终止了抽象干吗呀，谁能实现的了啊
static用static修饰的方法可以用类名去调用，可定义抽象类，抽象方法都没具体实现，你用类名去调用有什么意义啊
接口的特点：
1.接口用关键字interface表示
interface 接口名
2.类实现接口用implements 接口名{}
class 类名 implements 接口名{}
3.接口不能实例化
那么，接口如何实例化呢？
按照多态的方式来实例化
4.接口的子类
可以是抽象类，但是意义不大。
可以是具体类，要重写接口中的所有的抽象方法
由此可见：
1.具体类多态（几乎没有为了讲课需要）
2.抽象类多态（常用）
3.接口多态（最常用）
接口成员特点：
成员变量：只能是常量，并且是静态的
默认修饰符：public static final
建议：自己手动给出
构造方法：接口没有构造方法，因为接口主要是扩展功能的，而没有具体存在
成员方法：只能是抽象方法
默认修饰符：public abstract
建议：自己手动给出
所有的类都默认继承一个类：Object
类Object是类层次结构的根类，每个类都使用Object作为超类
类与类：
继承关系，只能是单继承，可以多层继承
类与接口：
实现关系，可以单实现，也可以多实现
接口与接口：
继承关系，可以单继承，也可以多继承
抽象类与接口的区别：
1.成员区别
抽象类：
成员变量：可以是变量，也可以是常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只能是常量
构造方法：压根没有好吧
成员方法：只可以是抽象的
2.关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承
3.设计理念区别
抽象类
被继承体现的是：“is a”的关系
抽象类中定义的是该继承体系的共性功能
接口
被实现体现的是:"like a"的关系，
接口中定义的是该继承体系的扩展功能
形式参数：
基本类型（这个直接使用就可以）
引用类型：
类名：需要的是该类的对象
抽象类：需要的是该抽象类的子类对象
接口：需要的是该接口的实现类的对象
包：
1.其实就是文件夹
2.作用
1.把相同的类名放到不同的包中
2.对类进行分类管理
包的定义：
pack 包名;
多级包用.分开即可
例如：package.cn.itcast;
注意事项：
1.package语句必须是程序的第一条可执行的代码
2.package语句自一个java文件夹中只能有一个
3.如果没有package，默认表示无名包
带包的编译和运行
1.手动式
1.编写一个带包的java文件
2.通过javac命令编译该java文件
3.手动创建包名（去创建文件夹）
4.把b步骤的class文件放到c步骤的最底层包
5.回到和包根目录在同一目录的地方，然后（带包）运行
2.自动式
1.编写一个带包的java文件
2.javac编译的时候带上-d即可
javac -d .helloworld.java
3.回到和包根目录在同一目录的地方，然后（带包）运行
导包概述
不同包下的类之间的访问，我们发现，每次是使用不同包下的类的时候，都需要加包的路径，比较麻烦，这个时候，java就提供了导包的功能
修饰符：
权限修饰符：private，默认，protected，public
状态修饰符：static，final
抽象修饰符:abstract
类：
权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract
用的最多的是：public
成员变量：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
用的最多的就是：private
构造方法
权限修饰符：private，默认的，protected，public
用的最多的是public
成员方法
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
用的最多的是：public
内部类概述：
把类定义在其他类的内部，这个类就被称为内部类
举例;在A类中定义了一个类B，类B就是内部类
内部类的访问特点：
1.内部类可以直接访问外部类的成员，包括私有
2.外部类要访问内部类的成员，必须创建对象
内部类的分类：
成员内部类
局部内部类
成员内部类：
如何直接访问内部类的成员
外部类名.内部类名 对象名 = 外部类.内部类对象
Outer.Inner oi = new Outer().new Inner();
成员内部类的修饰符：
private 为了保证数据的安全性
static 为了方便访问数据
注意：静态内部类访问的外部类数据必须用静态修饰，因为静态只能访问静态
内部类可以用静态修饰，是因为内部类可以看出是外部类的成员
成员内部类被静态修饰后的访问方式是：
外部类名.内部类名. 对象名 = new 外部类名.内部类名（）；
Outer.Inner oi = new Outer.Inner();
oi.show();
或者可以使用另外一种调用方法
Outer.Inner.show（）；
为什么加了static就要用类名呢，不是之前的对象呢，你都静态了。创造个什么对象啊
面试题：
class Outer{
public int num = 10;
class Inner{
public int num = 20;
public void show(){
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(new Outer().num);
或者是 System.out.println(Outer.this.num);
}
}
}
注意事项：
1.内部类和外部类没有继承关系
2.通过外部类名限定this对象
局部内部类：
1.可以直接访问外部类的成员
2.在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类的功能
注意事项：局部内部类访问局部变量必须用final，为什么呢？
因为局部变量是随着方法的调用而调用，随着调用完毕而消失
而堆内存的内容并不会立即消失，所以，我们加final修饰，加final后，这个变量就成了常量，既然是常量，你消失了，我在内存中存储的就是数据20，所以还有数据使用
匿名内部类
就是内部类的简化写法
前提：存在一个类或者接口
这里的类可以是具体类，也可以是抽象类
格式：
new 类名或者接口名（）{
重写方法；
}
匿名内部类的本质是什么呢？
是一个继承类或者实现了该接口的子类匿名对象
//用法一
interface Inter{
public abstract void show();
}
class Outer{
public void methoh(){
new Inter(){
pubic void show(){
System.out.println("show");
}
}.show();//第一种方法，这样直接调用
}
}
class InnerClassDemo{
public static void main(String [] args){
Outer o = new Outer();
o.method();
}
}
//用法二
interface Inter{
public abstract void show();
}
class Outer{
public void methoh(){
Inter i = new Inter(){ //第二种采用多态
pubic void show(){
System.out.println("show");
}
}.show();
}
i.show()；//利用多态调用
}
class InnerClassDemo{
public static void main(String [] args){
Outer o = new Outer();
o.method();
}
}