一、匿名对象
概念：匿名对象是指在创建对象时，只有创建的语句，却没有把对象地址值赋给某个变量。
特点：
（1）匿名对象直接使用，没有变量名。当做形参使用。
new Person().name="张三";
（2）匿名对象只能调用一次方法，再次调用相当于又创建了一个新的匿名对象
new Person().setName("小明");
System.out.println(new Person().getName()); //输出为空，因为又创建了一个新的匿名对象，跟上一个并没有关系
（3）作为返回值使用传递
public Person getPerson(){
//Person p=new Person(); //这一步骤省略直接用匿名对象来做返回值
//return p;
return new Person();
}
实例：
package com.oracel.demo03;
//匿名对象 自定义类
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean compare(Person p){
return this.age==p.age;
}
//匿名对象作为返回值来传递
public Person getPerson(){
//Person p=new Person();
//return p;
return new Person();
}
}
package com.oracel.demo03;
//测试类
public class Test {
public static void main(String[] args){
//有名对象
// Person p=new Person();
// p.setName("张三");
// p.getName();
// //匿名对象（只能调用一次方法） new:创建 Person():对象 合起来就是创建对象
// new Person().setName("阿莱");
// System.out.println(new Person().getName());
// //匿名对象当做形参传递
// p.compare(new Person());
//匿名对象的三个作用：1.调用一次方法2.当做形参传递3.作为返回值来传递
}
}
二、内部类
概念：将类写在其他类的内部，可以写在其他类的成员位置或局部位置，称为内部类，而“其他类”则称为外部类。
什么时候会使用？
在描述一个事物时，若事物内部还包含有其他可能包含的事物，比如在描述汽车时，汽车内部还包含着发动机，则发动机就可以用内部类来描述。
格式：
class Car{ //car 就是外部类
class FaDongJi{ //fadongji 就是内部类
}
}
内部类的分类：
内部类还可以分为成员内部类和局部内部类。成员内部类就是在成员位置的内部类，而局部内部类则是在局部方法内的内部类。
定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符 、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。
2.1成员内部类
定义格式：
class 外部类名称{
修饰词 class 内部类名称{
}
}
访问方式：
外部类名称.内部类名称 变量名称=new 外部类名称().new 内部类名称();
Car.FaDongJi cf=new Car().new FaDongJi();
2.2局部内部类
定义格式：
class 外部类名称{
public void method(){ //外部类的局部方法
class 局部内部类名称{ //局部内部类
}
}
}
访问方式：在外部类方法中创建局部内部类的对象，进行访问。
package com.oracel.demo03;
public class Jeep {
public void show(){ //外部类的方法
//局部内部类
class gulu{
public void method(){
System.out.println("这是轱辘的方法");
}
}
//局部类访问方法：在外部类方法中，创建内部类对象，进行访问
gulu g=new gulu(); //内部类的对象
g.method();
}
}
//在main方法中，创建外部类对象，调用局部方法，就可以访问局部内部类了
public class demo01{
public static void main(String[] args){
Jeep j=new Jeep();
j.gulu();
}
}
内部类的实际应用---匿名内部类
概念：最常用到的内部类就是匿名内部类，它是局部内部类的一种。
定义的匿名内部类有两种含义：
（1）临时定义某一指定类型的子类
（2）定义后即刻创建刚刚定义的这个子类的对象
作用与格式：
作用：匿名内部类是创建某个类型子类对象的快捷方式。
格式：
new 父类或接口（）{
//进行方法重写
};
练习题：编写一个抽象类Phone,两个抽象方法,call() sendMessage()
两个子类OldPhone 和 NewPhone , 其中NewPhone想添加一个玩游戏的功能.
请根据接口的思想实现,并用匿名内部类的方式调用玩游戏的功能.
//父类
package com.oracel.homework;
public abstract class Phone {
public abstract void call();
public abstract void sendMessage();
}
//旧手机子类
package com.oracel.homework;
public class OldPhone extends Phone{
public void call() {
System.out.println("旧手机打电话");
}
public void sendMessage() {
System.out.println("旧手机发短信");
}
}
//接口：玩游戏
package com.oracel.homework;
public interface PlayGame{
public abstract void playgames();
}
//新手机子类
package com.oracel.homework;
public class NewPhone extends Phone implements PlayGame{
public void call() {
System.out.println("新手机打电话");
}
public void sendMessage() {
System.out.println("新手机发短信");
}
public void playgames(){
}
}
//测试类package com.oracel.homework;
public class Test {
public static void main(String[] args) {
new OldPhone().call();
new OldPhone().sendMessage();
new NewPhone().call();
new NewPhone().sendMessage();
//用匿名内部类 重写方法 输出方法
new NewPhone(){
public void playgames(){
System.out.println("新手机玩游戏");
}
}.playgames();
}
}
三、包的声明和格式
概念：java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件。
当类文件很多的时候，通常我们会采用多个包进行存放管理他们，这种方式称为分包管理。
在项目中，我们将相同功能的类放到一个包中，方便管理。并且日常项目的分工也是以包作为边界。
类中声明的包必须与实际class文件所在的文件夹情况相一致，即类声明在a包下，则生成的.class文件必须在a文件夹下，否则，程序运行时会找不到类。
声明格式：
通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接
package 包名.包名.包名....；
如：Oracle.com包名反写为com.oracle
注意：包的声明，必须在有效代码的第一行!!!!!!!!
包的访问：
在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.类名）。
//包名.包名….类名
java.util.Scanner
java.util.Random
com.oracle.Demo
//带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();
com.oracle.Demo d = new com.oracle.Demo();
前提：包的访问与访问权限密切相关，这里以一般情况来说，即类用public修饰的情况。
类的简化访问：
当我们要使用一个类时，这个类与当前程序在同一个包中（即同一个文件夹中），或者这个类是java.lang包中的类时通常可以省略掉包名，直接使用该类。
Person p=new Person();
当我们要使用的类，与当前程序不在同一个包中（即不同文件夹中），要访问的类必须用public修饰才可访问。
package com.oracle02;
public class Person {}
四、import导包
概念： 我们每次使用类时，都需要写很长的包名。很麻烦，我们可以通过import导包的方式来简化。
可以通过导包的方式使用该类，可以避免使用全类名编写（即，包类.类名）。
格式：
import 包名.类名；
注意： import导包代码书写的位置：在声明包package后，定义所有类class前，使用导包import包名.包名.类名;
五、访问修饰符
Java中提供了四中访问权限修饰符：
public protected default private
下图为访问能力：
总结：
（1） 要想仅能在本类中访问使用private修饰；
（2）要想本包中的类都可以访问不加修饰符即可
（3）要想本包中的类与其他包中的子类可以访问使用protected修饰
（4）要想所有包中的所有类都可以访问使用public修饰
注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。
六、代码块
1.局部代码块
定义：局部代码块是定义在方法或语句中
特点：
（1）.以”{}”划定的代码区域，此时只需要关注作用域的不同即可
（2）.方法和类都是以代码块的方式划定边界的
2.构造方法块
构造代码块是定义在类中成员位置的代码块
特点：
（1）.优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作
（2）.每创建一个对象均会执行一次构造代码块
3.静态代码块
定义：静态代码块是定义在成员位置，使用static修饰的代码块。
特点：
（1）. 它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。
（2）. 该类第一次创建对象时执行，该类不管创建多少对象，静态代码块只执行一次。
（3）.可用于给静态变量赋值，用来给类进行初始化
练习题：
package com.oracel.demo03;
//匿名对象 自定义类
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean compare(Person p){
return this.age==p.age;
}
//匿名对象作为返回值来传递
public Person getPerson(){
//Person p=new Person();
//return p;
return new Person();
}
}
原文地址：https://www.cnblogs.com/0328dongbin/p/9073001.html