JAVA学习之基础学习(二)

JAVA学习之基础学习(二)

Scanner类

**定义:**一个可以解析基本类型和字符串的简单文本扫描器。

在使用一个类的时候要先实例化该类，创建一个该类的对象。

数据类型 变量名 = new 数据类型(参数列表);
Scanner sc = new Scanner(System.in)

调用方法

调用该类的成员方法，完成指定功能。

变量名.方法名();
int i = sc.nextInt();

Scanner使用步骤

查看类

• java.util.Scanner:该类需要import导入后使用

查看构造方法

• public Scanner(InputStream source):构造一个新的 Scanner ，它生成的值是从指定的输入流扫描的。

查看成员方法

• public int nextInt():将输入信息的下一个标记扫描为一个int值。

使用Scanner类，完成接收键盘录入数据的操作：

//1.导包
import java.util.Scanner;
public class Demo_SCanner{
	public static void main(String[] args) {
		//2.创建键盘录入数据对象
		Scanner sc = new Scanner(System.in);
		//3.接收数据
		System.out.println("请录入一个整数：");
		int i = sc.nextInt();
		//4.输出数据
		System.out.println("i:"+i);
	}
}

匿名对象

概念

创建对象时，只创建对象，不把对象地址赋值给某个变量。

• 匿名对象：没有变量名的对象。

  new 类名(参数列表);

  new Scanner(System.in);
  

应用场景

1. 创建匿名对象字节调用方法，没有变量名。

   new Scanner(System.in).nextInt();
   

2. 一旦调用两次方法，就是创建了两个对象，造成浪费

   new Scanner(System.in).nextInt();
   new Scanner(System.in).nextInt();
   

   注：一个匿名对象，只能使用一次

3. 匿名对象可以作为方法的参数和返回值

   • 作为参数：

     class Test {
     	public static void main(String[] args) {
     		// 普通方法
     		Scanner sc = new Scanner(System.in);
     		input(sc);
     		
     		// 匿名对象作为方法接收的参数
     		input(new Scanner(System.in));
     	}
     	
     	public static void input(Scanner sc){
     		System.out.println(sc);
     	}
     }
     

   • 作为返回值

     class Test2 {
     	public static void main(String[] args) {
     		// 普通方式
     		Scanner sc = getScanner();
     	}
     	
     	public static Scanner getScanner(){
     		// 普通方式
     		Scanner sc = new Scanner(System.in);
     		return sc;
     		
     		// 匿名对象作为方法返回值
     		return new Scanner(System.in);
     	}
     }
     

ArrayList类

数组的长度是固定的，java提供了另一个容器java.util.ArrayList集合类。

查看类

• java.util.ArrayList<E>:该类需要import 导入后使用。

  <E>表示一种制定的数据类型，叫做泛型。E,取自Element(元素)的首字母。再出现E的地方，我们使用一种引用数据类型将其替换即可，表示我们将存储哪种引用类型的元素。

  ArrayList<String>,ArrayList<Student>
  

查看构造方法

• public ArrayList():构造一个内容为空的集合。

基本格式：

ArrayList<String> list = new ArrayList<String>();

在JDK 7后,右侧泛型的尖括号之内可以留空，但是<>仍然要写。简化格式：

ArrayList<String> list = new ArrayList();

查看成员方法

• public boolean add(E e): 将指定的元素添加到此集合的尾部。

  参数E e,在构造ArrayList对象时，<E>指定了什么数据类型，那么add(E e)方法中，只能添加什么数据类型的对象。

使用ArrayList类，存储三个字符串元素：

public class Test {
	public static void main(String[] args) {
		// 创建数组
		ArrayList<String> list = new ArrayList<>();
		// 创建学生对象
		String s1 = "曹操";
		String s2 = "刘备"；
		String s3 = "孙权";
		// 打印学生ArrayList集合
		System.out.println(list);
		// 把学生对象作为元素添加到集合
		list.add(s1);
		list.add(s2);
		list.add(s3);
		// 打印学生ArrayList集合
		System.out.println(list);
	}
}

集合常用的方法：

• public boolean add(E e) ：将指定的元素添加到此集合的尾部。
• public E remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
• public E get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
• public int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

存储基本数据类型

ArrayList对象不能存储基本类型，只能存储引用类型的数据。但是可以存储转换后的基本数据类型。

基本类型	基本类型包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

public class Demo {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(1);
		list.add(2);
		
		System.out.println(list);
	}
}

数值添加到集合

生成6个1~33之间的随机整数,添加到集合,并遍历

public clas Test{
	public static void main(String[] args) {
		// 创建Random 对象
		Random random = new Random();
		// 创建ArrayList对象
		ArrayList<Integer>list = new ArrayList<>();
		// 添加随机数到集合
		for (int i = 0; i < 6; i++) {
			int r= random.nextInt(33) + 1;
			list.add(r);
		}
		// 遍历集合输出
		for (int i = 0;i < list.size(); i++) {
			System.out.print(list.get(i));
		}
	}
}

对象添加到集合

自定义4个学生对象,添加到集合,并遍历

public class Test {
	public static void main(String[] args) {
		// 创建集合对象
		ArrayList<Student> list = new ArrayList<>();
		// 创建学生对象
		Student s1 = new Student("张三",18);
		Student s2 = new Student("李四",19);
		// 把学生对象作为元素添加到集合中
		list.add(s1);
		list.add(s2);
		// 遍历集合
		for(int x = 0;x < list.size();x++) {
			Student s = list.get(x);
			System.out.println(s.getName()+"...."s.getAge())
		}
	}
}

打印集合方法

定义以指定格式打印集合的方法(ArrayList类型作为参数)，使用{}扩起集合，使用@分隔每个元素。格式参照 {元素

@元素@元素}。

public class Test {
	public static void main(String[] args) {
		// 创建集合对象
		ArrayList<String> list = new ArrayList<String>();
		// 添加字符串到集合中
		lsit.add("张三丰");
		list.add("张无忌");
		// 调用方法
		printArrayList(list);
		
		public static void printArrayList(ArrayList<String> list) {
		// 拼接左括号
			System.out.print("{");
		// 遍历集合
		for (int i = 0;i < list.size(); i++){
			// 获取元素
			String s = list.get(i)
			// 拼接@符号
			if (i != list.size() - 1) {
				System.out.print(s + "@");
			}else {
				// 拼接右括号
				System.out.print(s + "}");
			}
			
		}
			
		}
		
	}
}

获取集合的方法

定义获取所有偶数元素集合的方法(ArrayList类型作为返回值)

pulic class test {
	pulic static void main(String[] args) {
		// 创建Random 对象
		Random random = new rnadom();
		// 创建ArrayList对象
		ArrayList<Integer> list = new ArrayList<>();
		
		// 添加随机数到集合
		for (int i = 0; i < 20; i++) {
			int r = random.nextInt(1000) + 1;
			list.add(r);
		}
		
		// 调用偶数集合的方法
		ArrayList<Integer> arrayList = getArrayList(list);
		System.out.println(arrayList);
	}
	
	public static ArrayList<Integer> getArrayList(ArrayList<Integer> list) {
		// 创建小集合，来保存偶数
		ArrayList<Integer> smallList = new ArrayList<>();
		for (int i = 0;i < list.size();i++) {
			// 获取元素
			Integer num = list.get(i);
			// 判断为偶数，添加到小集合中
			if (num % 2 == 0) {
				smallList.add(num);
			}
		}
		// 返回小集合
		return smallList;
	}
}

继承

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字修饰 父类成员变量，类似于之前学过的 this 。

class Zi extends Fu{
	// Zi中的成员变量
	int num = 6;
	public void show() {
		// 访问父类中的num
		System.out.println("Fu num" + super.num);
		// 访问子类中的num
		System.out.println("Zi num" + this.num);
	}
}

成员方法重名——重写（Override）

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。

注意事项：

1. 子类方法覆盖父类方法，必须要保证权限大于等于父类权限
2. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样

继承后的特点——构造方法

1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2. 构造方法的作用是初始化成员变量。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个super(),表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

class Fu {
	private int n;
	Fu(){
		System.out.println("Fu()");
	}
}

class Zi extends Fu {
	Zi(){
		// super(), 调用父类构造方法
		super();
		System.out.println("Zi()");
	}
}

public class ExtendDemo{
	public static void main (String args[]){
		Zi zi = new Zi();
	}
}

继承的特点

1. Java只支持单继承，不支持多继承。
2. Java支持多层继承(继承体系)。
3. 子类和父类是一种相对的概念。

注：顶层父类是Object类。所有的类默认继承Object，作为父类。

抽象类

由来

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有 意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法 的类就是抽象类。

定义

• 抽象方法：没有方法体的方法
• 抽象类：包含抽象方法的类

abstract使用格式

抽象方法

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；

public abstract void run()；

抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。

抽象方法的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

public class Cat extends Animal {
	public void run (){
		System.out.println("小猫在墙头走~");
	}
}

public class CatTest {
	public static void main(String[] args){
		// 创建子类对象
		Cat c = new Cat();
		// 调用run方法
		c.run();
	}
}

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

接口

接口，是java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK7及以前），默认方法和静态方法（JDK8），私有方法（JDK9）。

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并 不是类，而是另外一种引用数据类型。

定义格式

含有抽象方法

抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

public interface InterFaceName {
	public abstract void method();
}

含有默认方法和静态方法

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。

静态方法：使用 static 修饰，供接口直接调用。

public interface InterFaceName {
	public default void method() {
		// 执行语句
	}
	public static void methods() {
		// 执行语句
	}
}

含有私有方法和私有静态方法

私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。

public interface InterFaceName {
	private void method() {
		// 执行语句
	}
}

基本的实现

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类

似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。

非抽象子类实现接口：

1. 必须重写接口中所有抽象方法。

2. 继承了接口的默认方法，即可以直接调用，也可以重写。

class 类名 implements 接口名 {
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【可选】
}

抽象方法的使用

必须全部实现，代码如下：

定义接口：

public interface LiveAble {
	// 定义抽象方法
	public abstract void eat();
	public abstract void sleep();
}

定义实现类：

public class Animal implements LiveAble {
	@Override
	public void eat() {
		System.out.println()
	}
}

定义测试类：

public class InterfaceDemo {
	public static void main(String[] args) {
		// 创建子类对象
		Animal a = new Animal();
		// 调用实现后的方法
		a.eat();
		a.sleep();
	}
}

默认方法的使用

可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

1. 继承默认方法，代码如下

   定义接口：

   public interface LiveAble {
   	public default void fly(){
   		System.out.println("天上飞");
   	}
   }
   

   定义实现类：

   public class Animal implements LiveAble {
   	// 继承，什么都不用写，直接调用
   }
   

   定义测试类：

   public class InterfaceDemo {
   	public static void main(String[] args) {
   		// 创建子类对象
   		Animal a = new Animal();
   		// 调用默认的方法
   		a.fly();
   	}
   }
   

2. 重写默认方法，代码如下：

   定义接口：

   public interface LiveAble {	
   	public default void fly(){
   		System.out.println("天上飞");
   	}
   }
   

   定义实现类：

   public class Animal implements Liveble {
   	@Override
   	public void fly() {
   		System.out.println("自由自在的飞");
   	}
   }
   

   定义测试类：

   public class InterfaceDemo {
   	public static void main(String[] args) {
   		// 创建子类对象
   		Animal a = new Animal();
   		// 调用重写方法
   		a.fly();
   	}
   }
   

静态方法的使用

静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，代码如下：

定义接口：

public interface LiveAble {
	public static void run() {
		System.out.println("跑起来");
	}
}

定义实现类：

public class Animal implements LiveAble {
	// 无法重写静态方法
}

定义测试类：

public class InterfaceDemo {
	public static void main(String[] args) {
		// Animal.run(); // 【错误】 无法继承方法，也无法调用
		LiveAble.run();
	}
}

私有方法的使用：

• 私有方法：只有默认方法可以调用
• 私有静态方法：默认方法和静态方法可以调用

如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有方法是对默认方法和静态方法的辅助。

定义接口：

public interface LiveAble {
	default void func(){
		func1();
		func2();
	}
	
	private void func1(){
		System.out.println("跑起来");
	}
	
	private void fun2(){
		System.out.println("跑起来")
	}
}

接口的多实现

在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

class 类名 [extends 父类名] implements 接口1，接口2，接口3...{
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法 【不重名时可选】
}

抽象方法

接口中，有多个抽象方法时，实现类必须重写所有抽象方法**。如果抽象方法有重名的，只需要重写一次。**

interface A {
	public abstract void showA();
	public abstract void show();
}

interface B {
	public abstract void showB();
	public abstract void show();
}

定义实现类：

public class C implements A,B{
	@override
	public void showA(){
		System.out.println("showA");
	}
	
	@Override
	public void showB(){
		System.out.println("showB");
	}
	
	@Override
	public void show(){
		System.out.println("show");
	}
}

默认方法

接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。

定义多个接口：

interface A {
	public default void showA();
	public default void show();
}

interface B {
	public default void showB();
	public default void show();
}

定义实现类：

public class C implements A,B{
	@Override
	public void show(){
		System.out.println("show");
	}
}

静态方法

接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

优先级的问题

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执

行父类的成员方法。代码如下：

定义接口：

interface A {
	public default void methodA(){
		System.out.println("AAAAAAAA");
	}
}

定义父类：

class D {
	public void methodA(){
		System.out.println("DDDDDDDDDDDD");
	}
}

定义子类：

class C extends D implements A {
	// 未重写methodA方法
}

定义测试类：

public class Test {
	public static void main(String[] args) {
		C c = new C();
		c.methodA();
	}
}
输出结果：
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDD

接口的多继承

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继 承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。

定义父接口：

interface A {
	public default void method(){
		System.out.println("AAAAAAAA");
	}
}

interface B {
	public default void method(){
		System.out.println("BBBBBBBB");
	}
}

定义子接口：

interface D extends A,B{
	@Override
	public default void method() {
		System.out.println("DDDDDDD");
	}
}

注：

• 子接口重写默认方法时，default关键字可以保留。
• 子类重写默认方法时，default关键字不可以保留

其他成员特点

• 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰
• 接口中，没有构造方法，不能创建对象
• 接口中，没有静态代码块

多态

定义

• 多态：是指同一行为，具有多个不同表现形式。

多态的体现

多态体现的格式：

父类类型 变量名 = new 子类对象； 
变量名.方法名();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写 后方法

定义父类：

public abstract class Animal {
	public abstract void eat();
}

定义子类：

class Cat extends Animal {
	public void eat(){
		System.out.println("吃鱼");
	}
}

class Dog extends Animal {
	public void eat(){
		System.out.println("吃骨头");
	}
}

定义测试类：

public class Test {
	public static void main(String[] args) {
		// 多态形式，创建对象
		Animal al = new Cat();
		// 调用的是Cat的eat
		al.eat();
		
		// 多态形式，创建对象
		Animal a2 = new Dog();
		// 调用的是Dog的eat
		al.eat();
	}
}

多态的好处

父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展 性与便利。

定义父类：

public abstract class Animal {
	public abstract void eat();
}

定义子类：

class Cat extends Animal {
	public void eat() { 
		System.out.println("吃鱼"); 
		} 
	}
class Dog extends Animal { 
	public void eat() {
		System.out.println("吃骨头"); 
			} 
		}

定义测试类：

public class Test {
	public static void main(String[] args) {
		// 多态形式，创建对象
		Cat c = new Cat();
		Dog d = new Dog();
		
		// 调用showCatEat
		showCatEat(c);
		// 调用showDogEat
		showDogEat(d);
		/*
		以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代 		 而执行效果一致
		*/
		showAnimalEat(c);
		showAnimalEat(d);
	}
	
	public static void showCatEat (Cat c){
		c.eat();
	}
	
	public static void showCatEat (Cat c){
		d.eat();
	}
	
	public static void showAnimalEat (Animal a){ 
		a.eat(); 
	}
	
}

由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当 然可以把Cat对象和Dog对象，传递给方法。

当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致， 所以showAnimalEat完全可以替代以上两方法。

不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。

所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

引用类型转换

多态的转型分为向上转型与向下转型两种：

• 向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

  当父类引用指向一个子类对象时，便是向上转型。

  父类类型 变量名 = new 子类类型（）；
  

• 向下转型：父类类型向子类类型向下转换的过程，这个过程四强制的。

  一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

  子类类型 变量名 = (子类类型) 父类变量名；
  如：Cat c = (Cat) a;
  

为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥 有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子

类特有的方法，必须做向下转型。

定义类：

abstract class Animal {
	abstract void eat();
}

class Cat extends Animal {
	public void eat() {
		System.out.println("吃鱼");
	}
	public void catchMouse() {
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	public void eat() {
		System.out.println("吃骨头");
	}
	public void watchHouse() {
		System.out.println("看家");
	}
}

定义测试类：

public class Test {
	public static void main(String[] args) {
		// 向上转型
		Animal a = new Cat();
		a.eat();  // 调用的是Cat的eat
		
		// 向下转型
		Cat c = (Cat)a;
		c.catchMouse(); // 调用的是Cat的 catchMouse
	}
}

转型的异常

public class Test {
	public static void main(String[] args) {
		// 向上转型
		Animal a = new Cat();
		a.eat(); // 调用的是 Cat 的 eat
		
		// 向下转型
		Dog d = (Dog)a;
		d.watchHouse();  // 调用的是 Dog 的 watchHouse 【运行报错】

final关键字

用于修饰不可改变的内容

修饰类

final class 类名 {
	
}

修饰方法

修饰符 final 返回值类型 方法名（参数列表）{
	// 方法体
}

修饰变量

1. 局部变量–基本类型

   基本类的局部变量，被final修饰后，只能赋值一次，不能再更改

   public class FinalDemo1 {
   	public static void main(String[] args) {
   		// 声明变量，使用final修饰
   		final int a;
   		a = 10;
   		// 第二次赋值
   		a = 20;  // 报错，不能赋值
   	}
   }
   

2. 局部变量–引用类型

   引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改

   public class FinalDemo2 {
   	public static void main(String[] args) {
   		//  创建User对象
   		final User u = new User();
   		// 创建另一个User对象
   		u = new User(); // 报错，指向了新的对象，地址改变
   		
   		// 调用setName方法
   		u.setName("张三"); // 可以修改
   	}
   }
   

3. 成员变量

   成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

   • 显示初始化

     public class User {
     	final String USERNAME = "张三";
     	private int age;
     }
     

   • 构造方法初始化

     final class User {
     	final String USERNAME;
     	private int age;
     	public User(String username, int age) {
     		this.USERNAME = username;
     		this.age = age;
     	}
     }
     

   注: 被final修饰的常量名称，一般都有书写规范，所有字母都大写。

权限修饰符

• public：公共的。
• protected：受保护的
• default：默认的
• private：私有的

	public	protected	default	private
同一类中	√	√	√	√
同一包中	√	√	√
不同包中的子类	√	√
不同包中的无关类	√

编写代码时，如果没有特殊的考虑，建议这样使用权限：

• 成员变量使用 private ，隐藏细节。
• 构造方法使用 public ，方便创建对象。
• 成员方法使用 public ，方便调用方法。

注：不加权限修饰符，其访问能力与default修饰符相同

内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

成员内部类

• 成员内部类 ：定义在类中方法外的类。

class 外部类 {
	class 内部类 {
		
	}
}

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类 Car 中包含发动机 类 Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。

访问特点:

• 内部类可以直接访问外部类的成员，包括私有成员。
• 外部类要访问内部类的成员，必须要建立内部类的对象。

创建内部类对象格式：

外部类名.内部类名 对象名 = new 外部类型（）.new 内部类型（）；

public class Person {
	private boolean live = true;
	class Heart {
		public void jump() {
			if(live) {
				System.out.println("心脏在跳动");
			} else {
				System.out.println("心脏不跳了");
			}
		}
	}
	
	public boolean isLive() {
		return live;
	}
	
	public void setLive(boolean live) {
		this.live = live;
	}
}

定义测试类：

public class InnerDemo {
	public static void main(String[] args) {
		// 创建外部类对象
		Person p = new Person();
		// 创建内部类对象
		Person.Heart heart = p.new Heart();
		
		// 调用内部类方法
		heart.jump();
		// 调用外部类方法
		p.setLive(false);
		// 调用内部类方法
		heart.jump();
	}
}

注：内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名 和 $符号 。 比如，Person$Heart.class

匿名内部类

new 父类名或者接口名（）{
	// 方法重写
	@Override
	public void method() {
		// 执行语句
	}
}

定义接口：

public abstract class FlyAble{
	public abstrct void fly();
}

创建匿名内部类并调用：

public class InnerDemo {
	public static void main(String[] args) {
		/*1.等号右边:是匿名内部类，定义并创建该接口的子类对象 2.等号左边:是多态赋值,接口类型引用指向子类对象 */
		FlyAble f = new FlyAble(){
			public void fly() {
				System.out.println("我飞了！");
			}
		};
		// 调用fly方法，执行重写后的方法
		f.fly();
	}
}

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。

public class InnerDemo2 {
	public class void main(String[] args) {
		/*1.等号右边:定义并创建该接口的子类对象 2.等号左边:是多态,接口类型引用指向子类对象 */
		FlyAble f = new FlyAble(){
			public void fly() {
				System.out.println("我飞了！");
			}
		};
		// 将f传递给showFly方法中
		showFly(f);
	}
	public static void showFly(FlyAble f) {
		f.fly();
	}
}

public class InnerDemo3 {
	public static void main(String[] args) {
		/*创建匿名内部类,直接传递给showFly(FlyAble f) */
		showFly(new FlyAble() {
			public void fly() {
				System.out.println("我废了！");
			}
		});
	}
	
	public static void showFly(FlyAble f) {
		f.fly();
	}
}

引用类型用法总结

class 作为成员变量

在定义一个类Role（游戏角色）时，代码如下：

class Role {
	int id;
	int blood;
	String name;
}

定义武器类，将增加攻击能力：

class Weapon {
	String name;
	int hurt;
}

定义穿戴盔甲类，将增加防御能力，也就是提升生命值

class Armour {
	String name;
	int protect;
}

定义角色类：

class Role {
	int id;
	int blood;
	String name;
	Weapon wp;
	Armour ar;
	
	// 提供get/set方法
	public Weapon getWp() { return wp; }public void setWeapon(Weapon wp) { this.wp = wp; }public Armour getArmour() { return ar; }public void setArmour(Armour ar) { this.ar = ar; }
}

	// 攻击方法
	public void attack(){
		System.out.println("使用"+ wp.getName() +", 造成"+wp.getHurt()+"点伤害");
	}
	
	// 穿戴盔甲
	public void wear(){ // 增加防御,就是增加blood值 this.blood += ar.getProtect(); System.out.println("穿上"+ar.getName()+", 生命值增加"+ar.getProtect()); }
	
	

测试类

public class Test {
	public static void main(String[] args) {
		// 创建Weapon 对象
		Weapon wp = new Weapon("屠龙刀" , 999999);
		// 创建Armour 对象
		Armour ar = new Armour("麒麟甲",10000);
		// 创建Role 对象
		Role r = new Role();
		// 设置武器属性
		r.setWeapon(wp);
		// 设置盔甲属性
		r.setArmour(ar);
		// 攻击
		r.attack();
		// 穿戴盔甲
		r.wear();
	}
}

接口作为成员变量

定义接口：

// 法术攻击
public interface FaShuSkill {
	public abstract void faShuAttack();
	}

定义角色类：

public class Role {
	FaShuSkill fs;
	public void setFaShuSkill(FaShuSkill fs) {
		this.fs = fs;
	}
	// 法术攻击
	public void faShuSkillAttack(){
		System.out.print("发动法术攻击:");
		fs.faShuAttack();
		System.out.println("攻击完毕");
	}
}

定义测试类

public class Test {
	public static void main(String[] args) {
		// 创建游戏角色
		Role role = new Role();
		// 设置角色法术技能
		role.setFaShuSkill(new FaShuSkill() {
			@Override
			public void faShuAttack() {
				System.out.println("纵横天下");
			}
		};
		
		// 发动法术攻击
		role.faShuSkillAtack();
		// 更换技能
		role.setFaShuSkill(new FaShuSkill() {
			@Override
			public void faShuAttack() {
				System.out.println("逆转乾坤");
			}
		};
		// 发动法术攻击
		role.faShuSkillAttack();
	}
}

接口作为方法参数和返回值类型

定义方法：

public static List<Integer>getEvenNum(List<Integer> list) {
	// 创建保存偶数的集合
	ArrayList<Integer> evenList = new ArrayList<>();
	// 遍历集合list, 判断元素为偶数，就添加到evenList中
	for(int i = 0; i < list.size(); i++) {
		Integer integer = list.get(i);
		if (integer % 2 == 0) {
			evenList.add(integer);
		}
	}
	return evenList;
}

调用方法：

public class Test {
	public static void main(String[] args) {
		// 创建ArrayList集合,并添加数字
		ArrayList<Integer> srcList = new ArrayList<>();
		for (int i = 0; i < 10; i++) {
			srcList.add(i);
		}
		/*获取偶数集合 因为getEvenNum方法的参数是List,而ArrayList是List的子类, 所以srcList可以传递 */
		List list = getEvenNum(srcList);
		System.out.println(list);
	}
	
}