【JavaSE学习笔记】面向对象_接口、形式参数问题、内部类

面向对象

A.接口

1）概述

动物类中的具体动物：猫和狗，有时候会具有额外的动作（跳高，计算等）

这些动作不能定义到具体类中，所以java针对这种情况，提供了一个关键字

interface：接口

2）定义格式：

类/接口的命名：首字母大写

interface 接口名{ }

interface Inter {}

3）特点

a.接口里面定义的方法，只能是抽象方法

b.接口中没有构造方法

c.接口的子类和接口的关系：实现关系，implements

子类 implements 接口{ }

class InterImpl implements Inter{}

4）接口和抽象类的区别（面试题）

a.成员的区别

接口：

成员变量：只能常量，默认修饰符 public static final，可省略，但不建议

成员方法：只能是抽象方法，默认修饰符 public abstract，可省略，但不建议

构造方法：无

interface Inter {
public static final int num = 20; // public static final可以省略

public abstract void method(); // 抽象方法
}

抽象类：

成员变量：可以是常量，也可以是变量

成员方法：可以抽象方法，也可以非抽象方法

构造方法：无参有参构造，对数据进行初始化

b.关系的区别

类与类的关系：继承(extends)：单继承，不能多继承

接口与接口的关系：继承(extends)：可以单继承，也可以多继承

interface Inter1 {}

interface Inter2 {}

interface Inter3 extends Inter1, Inter2 {}

类与接口的关系：实现(implements)：可以单实现，也可以多实现

class A implements Inter1, Inter2 {}

并且一个类继承另一个类的同时，也可以实现多个接口

class B extends A implements Inter1, Inter2 {}

c.设计理念的区别

继承体现的是一种"is a"的关系，由继承保证

接口体现的是"like a"的关系。接口多态的一种扩展功能

5）举例：猫狗案例，加入额外的跳高功能

a.分析

猫：

姓名，年龄，颜色

有参/无参

set()/get(),eat(),sleep(),show()

狗：

姓名，年龄，颜色

有参/无参

set()/get(),eat(),sleep(),show()

动物：

抽象类：

姓名，年龄，颜色

有参/无参

set()/get(),eat(),sleep(),show()

跳高功能：

部分猫和狗具有跳高功能

定义跳高接口

b.代码实现

动物类

//动物类
public abstract class Animal {
// 成员变量
private String name;
private int age;
private String color;

// 无参/有参构造
public Animal() {
super();
}

public Animal(String name, int age, String color) {
super();
this.name = name;
this.age = age;
this.color = color;
}

// set()/get()
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 String getColor() {
return color;
}

public void setColor(String color) {
this.color = color;
}

// show()
public void show() {
System.out.println(getName() + "---" + getAge() + "---" + getColor());
}

// 抽象方法eat()
public abstract void eat();

// 抽象方法sleep()
public abstract void sleep();
}

跳高接口

//跳高接口
public interface Jump {
// 抽象方法：跳高功能jump()
public abstract void jump();
}

猫类 extends 动物类

//猫类
public class Cat extends Animal {
// 无参/有参构造
public Cat() {
super();
}

public Cat(String name, int age, String color) {
super(name, age, color);
}

// 重写eat()
@Override
public void eat() {
System.out.println("猫吃鱼...");
}

// 重写sleep()
@Override
public void sleep() {
System.out.println("猫趴着睡觉...");
}

}

狗类 extends 动物类

//狗类
public class Dog extends Animal {
// 无参/有参构造
public Dog() {
super();
}

public Dog(String name, int age, String color) {
super(name, age, color);
}

// 重写eat()
@Override
public void eat() {
System.out.println("狗啃骨头...");
}

// 重写sleep()
@Override
public void sleep() {
System.out.println("狗卧着睡觉....");
}

}

跳高猫类 extends 猫类 implements 跳高接口

//跳高猫类
public class JumpCat extends Cat implements Jump {
// 无参/有参构造方法
public JumpCat() {
super();
}

public JumpCat(String name, int age, String color) {
super(name, age, color);
}

// 重写jump()
@Override
public void jump() {
System.out.println("猫可以跳高了...");
}

}

跳高狗类 extends 狗类 implements 跳高接口

//跳高狗类
public class JumpDog extends Dog implements Jump {
// 无参/有参构造方法
public JumpDog() {
super();
}

public JumpDog(String name, int age, String color) {
super(name, age, color);
}

// 重写jump()
@Override
public void jump() {
System.out.println("狗可以跳高了...");
}

}

测试类

//测试类
public class Demo {

public static void main(String[] args) {
// 跳高猫
JumpCat jc = new JumpCat("Tom", 5, "蓝色");
jc.show();
jc.eat();
jc.sleep();
jc.jump();
System.out.println("----------");

// 跳高狗
JumpDog jd = new JumpDog();
jd.setName("旺财");
jd.setAge(8);
jd.setColor("黑色");
jd.show();
jd.eat();
jd.sleep();
jd.jump();
}

}

B.形式参数问题

针对引用类型

1）类：

参数列表是引用类型：需要该类的对象

class Person {
public void show() {
System.out.println("show Person...");
}
}

class PersonDemo {
public void method(Person p) { // p = new Person();
p.show();
}
}

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 需求：需要调用PersonDemo中的method方法
// 常规方法
// 1)创建PersonDemo对象
PersonDemo pd = new PersonDemo();
// 2)创建Person对象
Person p = new Person();
// 3)将对象作为参数进行传递
pd.method(p);
System.out.println("---------------------");

// 匿名对象方法
new PersonDemo().method(new Person());
}
}

返回值是引用类型：返回的就是该类的对象

class Person {
public void show() {
System.out.println("show Person...");
}
}

class PersonDemo {
public Person method() {
// 常规方法
// Person p = new Person();
// return p;

return new Person(); // 匿名对象
}
}

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 常规方法
// 1)创建对象
PersonDemo pd = new PersonDemo();
// 2)使用pd
Person p = pd.method();
p.show();
System.out.println("-------------------");

// 匿名对象方法
new PersonDemo().method().show();
}
}

2）抽象类：

参数列表是引用类型：抽象类不能直接实例化，就需要抽象类的子类对象

abstract class Person {
public abstract void show();
}

class PersonDemo {
public void method(Person p) { // Person不能创建对象
p.show();
}
}

// 子类
class ZiPerson extends Person {

@Override
public void show() {
System.out.println("show...");
}

}

// 测试类
public class Demo01 {
public static void main(String[] args) {
/*
* 需求：调用PersonDemo中的method()方法
* 不能直接用PersonDemo的对象去调用method()
* 里面的参数是一个抽象类
* 而抽象类不能直接实例化
* 所以需要子类进行实例化
*/
PersonDemo pd = new PersonDemo();
// 抽象类多态
Person p = new ZiPerson();
pd.method(p);
System.out.println("------------------");

// 匿名对象
new PersonDemo().method(new ZiPerson());
}
}

返回值是引用类型：返回的是抽象类子类的对象

abstract class Person {
public abstract void show();
}

class PersonDemo {
public Person method() {
// ZiPerson zp = new ZiPerson();
// return zp;

return new ZiPerson();
}
}

// 子类
class ZiPerson extends Person {

@Override
public void show() {
System.out.println("show...");
}

}

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 方式1
PersonDemo pd = new PersonDemo();
Person p = pd.method();
p.show();
System.out.println("---------------");

// 方式2
new PersonDemo().method().show();
}
}

3）接口：

参数列表是引用类型：需要传递的是接口的子实现类对象

interface Inter {
public abstract void show();
}

class PersonDemo {
public void method(Inter i) { // 接口不能创建对象
i.show();
}
}

// 子实现类
class InterImpl implements Inter {

@Override
public void show() {
System.out.println("show...");
}

}

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 需求：调用PersonDemo中的method方法
// 方法1
PersonDemo pd = new PersonDemo();
Inter i = new InterImpl();
pd.method(i);
System.out.println("-----------------");

// 方法2
new PersonDemo().method(new InterImpl());
}
}

返回值是引用类型：返回的是子实现类的对象

interface Inter {
public abstract void show();
}

class PersonDemo {
public Inter method() {

// Inter i = new InterImpl();
// return i;

return new InterImpl();
}
}

// 子实现类
class InterImpl implements Inter {

@Override
public void show() {
System.out.println("show...");
}

}

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 方法1
PersonDemo pd = new PersonDemo();
Inter i = pd.method();
i.show();
System.out.println("-----------------");

// 方法2
new PersonDemo().method().show();
}
}

C.内部类

1）概述

在一个类中定义另一个类，内部类

class A {
class B {
}
}

B就是A的内部类

2）访问特点

内部类可以直接访问外部类的成员，包括私有！

外部类不能直接访问内部类的成员，需要在这里创建内部类对象，通过内部类对象调用方法

class Outer {
private int num = 10;

// 内部类
class Inner {
public void show() {
System.out.println(num);
}
}

public void method() {
// show();//不能直接访问内部类成员
Inner i = new Inner();
i.show();
}
}

3）分类

成员内部类：在外部类的成员位置

局部内部类：在外部类的局部位置

class Outer {
private int num = 10;

// 成员位置
// 成员内部类
// class Inner {}

public void method() {
// 局部位置
// 局部内部类
class Inner {}
}
}

4）成员内部类如何访问内部类的成员

不能直接创建对象：

格式：外部类名.内部类名 对象名 = 外部对象.内部对象;

class Outer {
private int num = 10;

// 成员内部类
class Inner {
public void show() {
System.out.println(num);
}
}
}

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 外部类名.内部类名 对象名 = 外部对象.内部对象;
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}

5）成员内部类有关的修饰符

可以是private：目的是保护数据的安全性

成员内部类：可以是静态的内部类：访问的外部数据，必须是静态的

class Outer {
private int num = 10;
private static int num2 = 100;

// 成员静态内部类
// 静态的内部类访问的外部类数据，外部类的成员必须是静态的
public static class Inner {
// 非静态方法
public void show() {
System.out.println(num2);
}

// 静态方法
public static void show2() {
System.out.println(num2);
}
}
}

6）成员静态内部类访问内部类成员的格式

格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 静态内部类访问自己成员的方式
// 外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = new Outer.Inner();
oi.show();
// oi.show2();
Outer.Inner.show2();// 静态方法，也可以这样访问
}
}

7）局部内部类

局部内部类的成员可以直接访问外部类的数据

局部位置访问成员内部类中成员方法，创建局部内部类对象

8）局部内部类访问成员变量要求？（面试题）

局部内部类访问局部变量，需要让局部使用final修饰，为什么？

局部变量随着方法的调用而存在，随着方法调用完毕而消失

不会立即消失，等待Gc空闲时刻进行垃圾回收，此时方法调用完毕

而局部内部类还在访问着，此时，就需要将变量用final修饰

（jdk 1.7.0_8以下必须带final，否则报错，以上可以省略final，系统默认为final修饰，建议不省略）

class Outer {
private int num = 10;

// 外部类成员方法
public void method() {
final int num2 = 20;

class Inner {
public void show() {
System.out.println(num);
System.out.println(num2); // jdk1.7.0_8以下必须加final,否则报错
}
}

// 局部内部类访问show()方法,创建局部内部类对象
Inner i = new Inner();
i.show();
}
}

// 测试类
public class Demo01 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}

9）匿名内部类

a.前提条件：有一个类或者接口存在，这个类可以是具体类，也可以是抽象类

b.格式：

new 类名/接口名(){

方法重写;

};

一个抽象对象：

interface Inter {
public abstract void show1();
}

class Outer {
public void method() {
// 调用一个方法
new Inter() {

@Override
public void show1() {
System.out.println("show1...");
}

}.show1();
}
}

// 测试类
public class Demo01 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}

多个抽象对象

interface Inter {
public abstract void show1();

public abstract void show2();
}

class Outer {
public void method() {
// 创建Inter对象
Inter i = new Inter() {

@Override
public void show2() {
System.out.println("show2...");
}

@Override
public void show1() {
System.out.println("show1...");
}
};
i.show1();
i.show2();
}
}

// 测试类
public class Demo01 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}

c.本质：需要继承该类或者实现该接口的子类对象

内部类与外部类没有继承关系

10）形式参数列表的问题（返回值类型问题详询【C-12)】）

接口：要该接口的子实现类，第二节中已讲到详询【B-3）第一条】

   不需要子实现类，使用匿名内部类（开发中使用）

interface Person {
public abstract void show();
}

class PersonDemo {
public void meyhod(Person p) {
p.show();
}
}

// 测试类
public class Demo01 {
public static void main(String[] args) {
// 匿名内部类方法
new PersonDemo().meyhod(new Person() {

@Override
public void show() {
System.out.println("show...");
}
});
}
}

11）面试题

/*
* 要求分别输出：30，20，10
*/
class Outer {
public int num = 10;

// 成员内部类
class Inner {
public int num = 20;

public void show() {
int num = 30;
// 输出30
System.out.println(num);
// 输出20
System.out.println(this.num); // 代表当前类的对象Inner
// 输出10
// 1)使用匿名对象的方式去访问
// Outer o = new Outer();
// System.out.println(o.num);
System.out.println(new Outer().num);
// 2)使用外部类名.this去掉用
System.out.println(Outer.this.num);
}
}
}

// 测试类
public class Demo01 {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}

12）面试题

/*
* 按照要求，补全代码
* 	Interface Inter {
* 		void show;
* 	}
* 	class Outer {
* 		//补齐代码
* 	}
*
* 	public class Demo01{
* 		public static void main(String[] args){
* 			Outer.method().show;
* 		}
* 	}
* 要求输出HelloWorld
*/

/*
* 1)类名调用方法:method()直接被Outer调用，所以被static修饰
* 2)method().show()：还可以调用接口中的show()，说明返回值类型对象是接口的子类对象Inter
* 			public static Inter method(){}
* 3)题中没有子类对象，所以返回匿名内部类对象
* 			public static Inter method(){
* 				return new Inter(){
* 					@Override
*					public void show() {
*
*					}
* 				};
* 			}
* 4)输出Hello World，则重写show()方法里应该是：System.out.println("Hello World");
*/

interface Inter {
void show();
}

class Outer {
// 补齐代码
public static Inter method() {
return new Inter() {

@Override
public void show() {
System.out.println("Hello World");
}
};
}
}

// 测试类
public class Demo01 {
public static void main(String[] args) {
Outer.method().show();
}
}

这道题返回值类型是接口，题中使用内部类来，不需要接口的子实现类