Java 学习入门

Java学习记录-入门

老博客没人看了，把东西搬过来…
记得不算很规整，但都是有用的部分

System.out.println();
这样轮空时是可以当成一个换行使用的。
进行除法运算时，牵扯到浮点数时，总会尽可能浮点位多地得到结果。
而只有整形参与运算时，就只会得到商。

Java的char类型：使用的是16位unicode

这里介绍方法的定义格式：
修饰符 返回值类型 方法名称（参数类型 参数名称，…）
{
方法体
return 返回值；
}
（现阶段）修饰符就是public static
方法的调用格式：
1.单独调用，方法名称（参数）
2.打印调用
3.赋值调用

parameter：参数 常简写为：param

在Java中：1.boolean类型不可以和其他类型混用，而且一切的逻辑运算的结果都时boolean类型。
2.对应的：一切带有返回值的方法，中一定要加上"return 返回值"这个语句，不然会报错
3.方法的返回值类型一定要和最后的return后的值为一个类型（可以自动类型转换过去的也算），不然也会报错
4.两个return不能连写

方法的重载（overload）：指的是多个方法的名称一样，但是参数列表不一样。（指的是形参的数据类型而不是形参的名称）
这个时候可以方便记忆多个功能类似的方法
重载与什么有关：
参数的个数
参数的类型
多类型顺序不同
重载与什么无关：
参数的名称
方法的返回值
此外，强调一个东西，由于方法调用时参数列表替换可以进行隐型的自动转换，所以：
short a=10;
short b=20;
public static double Method01（int a,int b）
{
return a*a;
}
public static double Method01（float a,float b）
{
return a+b;
}
使用方法Method01时会导致两者都行，但是不会报错，这个时候自动转到与实参最接近阶级的形参处的方法来调用。也就是说，调用第一个Method01。其他类似的也是这个规则。

在IntelliJ中，当在一个方法中有一个变量多次出现时，选中其中一个，按住shift+f6 即可同时改变所有的该变量的名称。

数组：一旦被创建，就在运行期间不能再进行修改。
动态初始化：int[] array1=new int[5];
静态初始化：int[] array2=new int[]{2,3,4,5,6};
上面的这两个是标准格式
静态初始化的省略格式：int[] array2={2,3,4,5,6};
上面两个标准格式还可以拆分成两个步骤：

int[] array1;
array1=new int[5];

=================================

int[] array2;
array2=new int[]{2,3,4,5,6};

但是静态初始化的省略格式无法拆分成两个步骤。

用sout尝试打印一个数组的名称会出现其地址的哈希值
动态初始化一个数组时，里面的数据会有一个默认值：
整数类型默认为0
浮点数类型默认为0.0
字符类型默认为’\u0000’————>这个东西是看不见的，就跟空气一样
布尔类型默认为false
引用类型默认为null

其实静态初始化的时候也有这个默认值的过程，但是只是这个默认值马上被新值覆盖了
Java的内存区分为五个部分：
1.栈（Stack）：存放的都是方法中的局部变量（包括它们的名称，数据类型（基本类型和引用类型都在这里面）以及引用类型的地址，这个地址联系到堆区中）。方法的运行一定要在栈当中运行
2.堆（Heap）：凡是new出来的东西，都在堆当中（数组无论咋着定义出来的都是在堆里面）
（既然声明出来的类的对象在heap中，那么其中的成员对象也在堆中）
3.方法区（Method Area）：储存class相关信息，包含方法的信息（包括main方法和其它方法的名字，返回值及）（但是方法的运行一定要在栈中）（更确切的说：包含成员变量，成员方法）
4.本地方法栈（Native Method Stack）：与操作系统相关
5.寄存器（PC register）：与CPU相关
用new进行动态初始化创建的方法形成的数组的默认值还不等于初始化，初始化使用户进行的赋值

Index：索引 exception：异常，意料之外的情况 Thread：线程
ArrayIndexOutOfBoundsException:数组越界异常

数组空指针异常（所有的引用类型都可以被给予一个null值，代表里面什么都没有）原因：没有new

数组名.length得到的是数组的长度
数组在运行过程中，长度无法改变。但是同一个数组名可以反复存放不同的数组（是一个引用）

for循环的另一个简便写法：
5.fori–>for(int i=0;i<5;i++)
如果有个数组名称为Array 则：
Array.fori–>for(int i=0;i<Array.length;i++)

【类与对象】
类：一件事物的描述，是抽象的；
对象：一类事物的实例，是具体的；
类是对象的模板，对象是类的实体；
用类创建对象，就是实例化：
对象：属性＆行为

成员变量（在对象创建后直接使用，会按照数组那样（int nums[]=new int[10]）有默认初始值）；

成员方法：成员方法不要写static
成员变量直接定义在类当中；

一个类的使用：
1.导包：将类和对象生成class放在一个包内，或者在main中用
import 包名称.类名称 来导入
2.创建：类名 对象名（理论上随便叫）=new 类名();
（这样的话，对象那个就被创建出来了）
3.使用：对象名.成员变量–>当作一个同类型的变量来使用和修改
对象名.成员方法

运行时，成员变量的数值在堆区，成员方法执行体在方法区；成员方法只有先到堆区找到其地址才可以到方法区执行

对象名（对象的引用名）储存的也是这个对象的地址。

main方法最后出栈，其他的任何方法都是运行完了再出栈

成员变量和局部变量：
1.定义位置不一样
局部变量：在方法内部
成员变量：在方法的外部，直接写在类当中
2.作用范围不一样
局部变量：只有方法当中才可以使用，方法之外就不可
成员变量：整个类通用
3.默认值不一样
局部变量：无
成员变量：有
4.内存位置不一样
5.生命周期不一样

private 修饰的使用方法：
在一个类中，于成员变量的数据类型前加上private的修饰，会使得这个变量在其它类中无法访问。
private 如果在类中定义成员变量或者方法的话，直接在类中可以直接用（就是main外面，class里面）；如果要在当前类的main里面使用的话，要创建当前类的对象，并且直接对象名.成员变量名修改；
只有在类外面才用getter setter；
private int age;
那么要使用这个变量时，需要在这个类中生成两个成员方法：
setXxx和getXxx（名称不可改变）
setXxx是用于给这个pri变量赋值，public void setXxx(int num)
{age=num;}
getXxx是用于使用这个变量,public int getXxx()
{return age;}
而在变量为boolean时，getter要变成isXxx
private boolean gender;
public void setGender(boolean boolgen)
{gender=boolgen;}
public boolean isGender()
{return gender;}

this关键字：在一个类中对于成员变量和成员方法中的参数重名时使用，在this后边的变量永远是对应的类的成员变量，这个this打印出来是与类名相同的地址，this也就是当前类的一个对象
构造方法：格式：public 类名(){}
这个是用来进行生成对象的方法，不可有返回值，但可以有参数。
一般使用时，程序会自动给我们在类函数里面附赠一个空的“public 类名（）{}”这样的方法，也就是我们构造对象时用的new后面的方法；这个方法可以有参数，也就是可以在new的时候顺带实现对这个新对象的操作。

然后是一个新的API：Scanner 用于读取从键盘上或者是其他地方输入的一些数据。
在进行new的时候，应当使用：Scanner sc=new Scanner(System.in); 进行创建，读取键盘上传来的数据。使用 nextInt(); 和 next(); 分别接收整型和字符串类型。

API：Random：随机数生成器 nextInt()这个成员方法括号内要是有个数的话，就会生成0-这个数-1这么范围内的一个数，没有的话生成±21亿以内的数

ArrayList集合：java.util.ArrayList
这个集合的长度不同与数组，可以进行改变,这个尖括号表示泛型，装在集合中的元素，全部都是统一的什么类型。（注意！泛型只可以是引用类型而不可以是基本类型）
ArrayList list=new ArrayList<>();
使用add()方法往里面放东西，多次调用，自动带逗号
public boolean add (E e)向集合当中添加元素， 参数的类型和泛型一致。ArrayList的添加返回值一定是true。
public E get(int index) ： 从集合当中获取元素， 参数是索引编号(form 0)， 返回值就是对应位置的元素。
E remove(int index)： 从集合当中删除元素， 参数是索引编号， 返回值就是除掉的元素。
public int size() : 获取集合的尺寸长度， 返回值是集合中包含的元素个数。使用时直接用一个int类型来接收list.size();即可
遍历时用list.fori进行生成

ArrayList这个范式里面，要是想用基本数据类型的话，要加上对应的包装类关键字。
在GDK1.5以后，支持了自动拆装包
所以用的时候就：list.add(100)这样就行了
int->Integer char->Character
别的就是变个大写

BigDecimal b2=BigDecimal.valueOf(0.123456789)这个东西的精度可以很高

字符串的创建：
1.空内容：String str=new String();
2.使用字符数组进行创建：char[] str1=new char[3]{‘A’,‘B’,‘C’};
3.使用byte类型数组进行创建，要使用字符的ascii码
4.直接创建：String str={"",""};

System.exit(0);(或者是-1)就是退出

关于字符串：由""装载的字符串存放在堆区的字符串常量池里，如果同时用快捷方法生成两个相同的字符串，那么第二个字符串的地址和第一个相同，共用池中的数据。如果使用含参数组的方式创建的话，就不在字符串常量池里，再将其创建时，其中的char型会被自动转换为byte型。==是进行地址值比较

public boolean equals（Object obj）（Object理论上能接受收所有对象类型，但是这个只有字符串类型相等的时候才会返回true值）方法：比较字符串相等，前后都可以只写一个字符串，推荐把纯字符串类型写在前面，防止空指针异常。

equalsIgnoreCase();只无视英文的大小写，也是比较
concat（String str）：连接字符串，返回新字符串；
charAt（int Index）；获取指定索引位置的单个字符char型
indexOf(String str); 查找参数字符串在目标字符串中首次出现的位置，找到返回索引int值，否则返回-1

java源文件至多只能有一个public类,这个类的名字与包名相同

在成员变量前面加上static，在其他的包中可以直接Student.这个变量名即可；

传递引用进方法时，这个引用的内容会随之改变。生成新的内容除外。

新的方法：split方法，返回值是String[] 类型
split(“要切掉的字符（串）”);
在切".“英文句点的时候要写成”\."才行，要注意
没有目标时全输出；
YYY切YY时用第一个Y
切几刀分n+1份

注意Java里面的{}在String str="";时，不能加到""外面！！

类中的静态static关键字修饰成员：
static String classnum;
这样再去生成对象的话：在对象中任意一个对象.classnum进行修改，修改的会是类中的classnum

static成员赋值先于构造方法

静态方法没有多态

使用自动变化的id对对象进行编号：
在类中加入：private static int id=0;
随后在构造方法中：

public Student()
{
	id++;
}
public Student(String name, int age)
{
	this.name=name;
	this.age=age;	
	id=++id;
}

这样的话每次调用构造函数创建一个新的对象都可以使得id自动变化

【重要】无论在什么地方，在本类里面也好在其他的类里面也好，普通、静态变量和方法始终遵循：
1.普通变量和方法都要使用：类的对象名.变量（方法）名来调用；（所以在本类里面是this关键字代替类的对象名，在其它类中是创建的对象的对象名）
2.静态变量和方法都要使用：类名.静态变量（方法）名来调用；（在其它类中也可以用定义的类的对象来当类名使用，这样不推荐，因为容易被误解成普通变量（或普通方法））

【重要】非静态成员方法可以访问非静态成员变量（方法），也可以访问静态成员（方法）；但是静态方法只能访问静态成员（方法），不能访问非静态成员（方法）;
在静态方法中，不能使用this关键字。
（使用了static定义意味着储存区域换到了静态储存区，这个区域储存所有的static静态信息）

在使用类名访问静态变量时，是通过栈里的Student.这个东西到达方法区继而到达静态区的，全程和对象没关系，只和类有关系
Student这个类里面的变量方法都会进到方法区里

静态代码块格式：（在类中，在main之外）static{}
这个东西的特点是：在第一次调用这个类的时候，他会执行唯一的一次，比如使用这个类的构造方法，而且他总是优先于构造方法执行的。

【New】Arrays是数组工具类，里面有很多静态方法，都是数组有关的方法，
[1]：toString：将参数变成字符串类型，也就是把一个数组变成字符串，并返回新的字符串，默认格式：[e1,e2,e3,e4…]这样
[2]：sort：将这个数组进行排序，按照从大到小的顺序，字符串数组也是如此，按照字母的ASCII，中文的话按照对应的数字。自定义类型的话，那么这个自定义类型的类需要有Comparable或者Comparator接口支持

【重要】（toCharArray这个方法可以把字符串格式的变成char型数组，返回一个char[]数组）

【重要】chars.fori这个生成的快速排列是正序，用chars.forr生成倒序。

【New】Math是数学工具类，里面有很多静态方法，是数学计算有关方法：
[1]：abs()取绝对值
[2]：ceil()向上取整
[3]：floor()向下取整
[4]：sqrt()开方
上面的返回值是double类型的
[5]：round()四舍五入
上面的这个是long型
PI是Π的近似值

不同的数据类型可以比较大小

【▲新的性质！！】继承
继承实际上是共性抽取
继承的格式：
需要父类和子类；父类和普通的类的创建没什么区别，里面主要是共性的成员。
子类是新开的类，也是public，要写成：public class Teacher extends Employee{}
在子类中可以直接当作有父类中的东西，创建对象然后对象.成员变量或方法就可以了。
在子类中使用成员变量和成员方法时：对于成员变量，子类中没有的就往上找，到父类中再没有才报错，如果与父类中的成员变量重名，则看这个成员变量是被谁.出来的就用谁的，子类会掩盖父类。对于成员方法，也是如此，静态方法的话，也是现在本层找变量，找到父层去的话，父层的变量必须也是静态的才行。

父类子类重名，父类静态方法，子类普通方法，报错（估计是重写失败）

【重要】重写（覆写:override）：在继承关系中，子类父类的方法名称一样，参数列表一样；这样的叫做覆写。
1.使用@Override 进行覆写检测，将这个检测符加在子类的覆写方法以前（前一行），可以判断是否为覆写；
2.进行覆写时，子类的方法的返回值范围必须小于等于父类方法的返回值范围：Object大于String；long>double>float>int>short>char>byte>boolean;否则报错
3.进行覆写时，子类的方法的限权范围要大于父类的范围：public>protected>(default)>private（这个用在父类的时候不知道为什么会报错）.否则也是报错

如果想在子方法（覆写或者新名称的子方法）中既保留原有的父类的某个方法的功能，又进行新方法创建，可以在里面加入：super.父方法名()；

构造方法的“继承”：
可以说子类中自动地带有这一行代码：
子类名()
{
super();
}
（说明super和this的区别：this本质上是当前类的一个虚拟对象没错，同时super本质上并非如此，它只是java的一个关键字而已）
1.子类的构造方法中有一个默认的super（）调用，所以一定是先调用的父类构造，后执行的子类构造
2.子类构造可以通过super关键字来调用父类重载构造
3.super的父类构造调用，必须是子类构造的第一个语句。不能一个子类构造调用多次super构造。
子类必须调用父类的构造方法，不写则赠送super（）；写了则用指定的super调用，super只能有一个，还必须是第一个

super关键字的用法：
1.在子类成员方法中，通过super.来调用父类成员变量
2.在子类成员方法中，通过super.来实现新的子方法继承
3.在子类的构造方法中访问父类的构造方法

this（关键字的用法）：
1.在本类的成员方法中，访问本类的另一个成员变量
2.在本类的成员方法中，访问本类的另一个成员方法（没啥用，就是字面强调一下）
3.在本类的构造方法中，访问本类的另一个构造方法：
this(…)的调用也是和super一样，需要在构造方法中的第一行，唯一一个
super和this不可同时出现，使用this的时候，就不会有super。
子类继承父类时放进方法区是会有标记的[[class_super]]

继承的特点：
1.不可同时继承两个父类，Java是单继承的
2.可以父类后跟子类，子类又作为父类，往后继承
3.可以一个父类被多个同级子类继承

（重点：当父类中有一个变量和子类重名时，在父类中有个方法是给这个变量赋值，那么当用子类对象调用这个方法时，改变的是父类中的值而不是子类中的变量值）

【重要/New】抽象：
如果父类当中的方法不确定如何使用方法体实现，那么这就应该是一个抽象方法

抽象方法的格式：public abstract void method();
这个抽象方法必须放在抽象类中，抽象类：public abstrct class DemoClass01{ … }

抽象类的使用：1.不能直接使用new来创建抽象对象，必须使用（非抽象的）子类来继承抽象的父类。
2.要使用覆盖重写（实现）来在子类中创建一个具体的方法。
去掉方法的abstract关键字，然后在后面加上大括号，补全其中的内容。（对于每一个父类的抽象方法都要如此）
3.创建子类的对象进行使用

抽象类里不一定有抽象方法，但是有抽象方法的正确的类一定是抽象类
如果对一个抽象类进行创建子类，如果子类为非抽象类，则会报错；不然，要将其中的覆盖重写补上才行。之所以会报错就是因为父类里面有抽象方法。也就是说非抽象子类继承抽象父类时，必须重写其中的所有抽象方法。

如果说有一个抽象父类，其中有不止一个抽象方法，则对于继承它的子类，必须要到全部的抽象方法被覆盖重写，才可以进行对象生成；否则只能继续往下创建抽象子类。

注意！！：说是不能使用继承来继承父类中的private变量，但是实际上可以的，只是必须用gettersetter来进行调用。
（上面这句话是错的，继承的只是这两个方法，并不是private变量）

【New】接口
格式：public interface 接口名称()
{接口内容}
接口就是多个类的公共规范；是一种引用数据类型，其中最重要的就是里面的抽象方法。
抽象方法的定义：这里面的抽象方法，修饰符必须是两个固定的关键字：public abstract（这两个可以选择性或者全部省略）
方法的三要素：名称，参数列表，返回值可以随意定义。
接口的使用：定义一个实现类：public class MyInterfaceAbsImpl Implements MyInterfaceAbs{}；这个类也要覆盖重写所有的接口中的抽象方法，否则它也只能是抽象类。

为了简化接口升级带来的麻烦，接口中新加了默认方法：
public default 返回值类型 方法名(参数列表){方法体}
这个默认方法很像普通父类里面的普通方法，也可以被实现类（子类）覆盖重写。覆盖重写后也是去掉default。

接口里面的静态方法：public static void MethodStatic(){ }，也是与实现类方法无关，只和接口名称有关，故调用方法和之前的静态方法一样

接口里面不得使用静态代码块！

使用私有方法来减少接口的默认方法的重复代码问题，直接定义
private void 名称(){ } 即可，而接口中的静态方法的代码重复问题就用 private static void 名称(){ }

对于直接在接口里面创建常量：int NUM; 这样是错的，因为这样创建相当于是：public static final int NUM ，这代表一个常量，不可改变。故必须要给他初始化一个值。

关于接口和继承：
1.接囗是没有静态代码块或者构造方法的。
2.一个类的直接父类是唯一的， 但是一个类可以同时实现多个接囗。
（如果实现了多个接口，则要覆写其中所有的抽象方法，否则这个类是抽象类）
3 ． 如果实现类所实现的多个接囗当中， 存在重复（名称和返回值类型）的抽象方法， 那么只需要覆盖重写一次即可。（如果返回值类型不一样的话会根本无法创建正确的覆写！）
4 ． 如果实现类没有覆盖重写所有接囗当中的所有抽象方法， 那么实现类就必须是一个抽象类。
5 ． 如果实现类所实现的多个接囗当中， 存在重复的默认方法， 那么实现类一定要对冲突的默认方法进行覆盖重写。
6 .一个类如果直接继承父类当中的方法， 和接囗当中的默认方法产生了冲突， 优先用父类当中的方法。（继承优先级高于接口的实现），如果父类的方法和接口里的抽象方法产生了冲突，那么优先覆写父类的方法
########################接口继承：
7.类与类之间是单继承的，直接父类只有一个，但是接口与接口之间是多继承的，类可以实现多个接口
8.多个父接口的抽象方法重复，没关系；多个父接口的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写；注意！！这个覆写是在接口中覆写默认方法，故要带着default，跟重新定义一样写。
9.接口可以继承接口！使用extends关键字
【New】多态
多态是指对象的多态，不是类的多态；比如父类是人，子类是学生；根据子类创建的对象就具有人和学生两种形态，称为多态
多态简单就一句话：父类引用指向子类对象；
父类名称 对象名 = new 子类名称();
也就是把子类对象当作父类来看待，由于是new zi();故调用方法时保留子类特性（方法的时候，new谁就先看谁，没有就往上找）
访问成员变量时：直接通过对象名称访问的，看看等号左边的使用谁定义的，就用谁的，没有则向上找
间接通过成员方法访问的，看看该方法属于谁，就用谁的，没有就向上找
当子类中对父类的方法进行了覆写，则按照新覆写的方法来，如果没覆写，就往上找父类，用父类里面的数据
口诀：成员变量：编译看左边，运行还是看左边；
成员方法：编译看左边，运行看右边；
左右是指的Fu fu=new Zi();的左右
编译通过指：这句话在编译器中没有爆红，则编译通过（看看放在左边的类里会不会有问题）
运行时是指：运行（看看这个方法放在右边的类里会不会有问题）
如果说父类里面有抽象方法，进行多态后也可以通过编译
接口也可以多态
使用多态，可以在改变对象的时候只去改变等号的右边，不管左边
【New】向上转型＆向下转型
向上转型是指的 父类名称 对象名称 = new 子类名称(); 这样的转型不会出错，一定是安全的；这样使用过后，会使得该对象无法调用子类的独有方法。因为无法通过调试
向下转型是指：在向上转型过后，得到对象animal，利用向下转型进行还原：Cat cat=(Cat) animal;
向下转完了之后就可以用子类的独有方法了。
这俩的搭配是这样：
先用一个父类被多个子类继承，然后向上转型来构造他们的对象，这时候都可以传到(Animal animal)的这个参数列表里了，传进去后使用if(animal Instanceof Cat){}else if(animal Instanceof Dog){}…进行判断，在大括号内向下转型，再进行使用
其实，如果未进行（手动）向上转型，直接将一个子类或者子接口传参给（父类名 父类对象）（父接口 父接口实现）这样的方法，也是可以的，因为这里会发生强制类型转换，直接小转大。甚至可以匿名对象（实现）传进去，但是必须注意传进去后先检验，后向下转型，才可以使用其独有方法。
动态绑定：1.子类对父类继承2.子类对父类方法重写3.父类引用指向子类对象（向上转型）也就是说如果向上转型时子类的“独有方法”是对父类的重写，那就可以用那个指向子类对象的父类引用调用子类中的重写方法（这个是一定的，就和抽象方法重写那个一样）
【New】
final关键字：
1.修饰一个类，这个类不能有子类，但是可以有父类。
2.修饰一个方法，这个方法无法在子类中被覆盖重写
（鉴于如此，abstract不能和final共用）
3.修饰局部变量（即所有的在方法大括号内的变量），这个局部变量的值在第一次被赋值后无法被改变。如果是引用类型，则代表着这个引用类型的地址值无法改变，但是通过这个引用调用的变量可以被改变。
4.修饰成员变量，成员变量若为private，则setter无法被使用；而且，必须手动给这个成员变量进行初始值赋值，没有直接赋值的话，就要在这个类的构造方法中进行赋值，所有的构造方法都要加入赋值操作。

四种权限修饰符：public > protected > (default) > privated
同一个类 YES YES YES YES
同一个包 YES YES YES NO
不同包子类 YES YES NO NO
不同包非子类 YES NO NO NO

内外部类：
分为：外部类，成员内部类和局部内部类；
根据名字判断位置即可，局部内部类就是在方法里面的类。
外部类：没什么，就是不能直接访问内部类，需要通过构造对象来进行调用；而且，外部类不可以使用protected，private 修饰符，但可以使用public和(default)修饰符。

成员内部类：能够直接访问外部类的方法和变量。其中的this关键字也适用，在内外部变量名重名时，要是想使用外部类的变量，则要通过两种方式：
1.new外部类名().外部变量名；2.外部变量名.this.外部变量名。如果其他类想要使用内部类的方法或者变量时，要么通过在外部类中构造方法，间接调用；要么使用公式构造对象：外部类名.内部类名 内部类对象名=new 外部类名().new 内部类名();

局部内部类：局部内部类定义在外部类里方法的里面，不可以使用任何修饰符，直接class 内部类名{};
只能本方法使用，在这个方法之外就不能用，故要使用这个类就要定义外部类的对象来调用这个方法。
局部内部类要是想使用这个方法里的局部变量，就要保证这个变量是final的，因为局部内部类new出来对象在堆里，而这俩的生命周期不一样长，故生命周期短的局部变量的值不能变化，（从Java8+开始，只要局部变量事实不变，那么final关键字可以省略）不要改变局部变量的值！

匿名内部类：省略了接口的实现类或是父类的子类，直接使用对象：
接口名 对象名=new 接口名(){这里面对所有的抽象方法进行重写（或者默认方法）};
父类名 对象名=new 父类名(){这里面…和上面一样};
对象名.变量或方法就可以了
但是要注意，使用这个匿名内部类的外部类，不应该继承这个父类或者实现这个接口。
也可以：new 接口名(){这里面对所有的抽象方法进行重写（或者默认方法）}.成员方法或变量;
new 父类名(){这里面… 和上面一样}.成员方法或变量;
这样一次只能进行一个调用。

使用类作为成员变量，正常创建对应类，类中的构造方法应涉及各变量，直接在其它类里面用这个类作为成员变量定义： 类名 成员变量名;
在使用时先创建成员变量的那个类的对象，然后把这个对象给成员变量即可。

【后记】：
如果一个接口中的抽象类存在，又有一个实现类去实现它，那么，如果没有完全实现其中的抽象方法，那么，这个类必须是抽象类。
接口中的成员变量自动具备着public static final属性。

Java编程思想：
关于内部类和static:
任何方法内部不可以定义static。
静态内部类在被使用时初始化，并不会提前加载。
静态内部类中不是不可以创建非静态变量或方法，而是不能调用
静态内部类中可以创建普通方法和static方法，使用类名调用肯定只能调用到static方法和变量。这不意味着他就不能被实例化了，被实例化之后他也可以调用其中的成员变量。
成员内部类不可以定义static类型：
由于成员内部类是跟随着实例化而创建的，所以不允许有静态内容。

静态内部类只能调用静态类型和方法。成员内部类都可以。
一般类的静态方法只能调用静态类型，成员方法都可以使用。
如果创建了对象，这时静态内部类可以调用一般方法和一般变量。
static方法没有this，因为他没有实例，并且，this也是实例化，相当于非静态方法。