Java基础4---面向对象之代码块、继承、final关键字、内部类

(代码块的概述和分类)(了解)(面试的时候会问,开发不用或者很少用)

  • A:代码块概述
    • 在Java中,使用{}括起来的代码被称为代码块。
  • B:代码块分类
    • 根据其位置和声明的不同,可以分为局部代码块,构造代码块,静态代码块,同步代码块(多线程讲解)
  • C:常见代码块的应用
    • a: ==局部代码块 ==
      • 方法中出现;限定变量生命周期,及早释放,提高内存利用率
    • b:构造代码块 (初始化块)
      • 在类中方法外出现;多个构造方法方法中相同的代码存放到一起,每次调用构造都执行,并且在构造方法前执行
    • c:静态代码块
      • 类中方法外出现,并加上static修饰;用于给类进行初始化在加载的时候就执行,并且只执行一次
      • 一般用于加载驱动

###08.02_面向对象(代码块的面试题)(掌握)

  • A:看程序写结果
class Student {
			static {
				System.out.println("Student 静态代码块");
			}
			
			{
				System.out.println("Student 构造代码块");
			}
			
			public Student() {
				System.out.println("Student 构造方法");
			}
		}
	
		class Demo2_Student {
			static {
				System.out.println("Demo2_Student静态代码块");
			}
			
			public static void main(String[] args) {
				System.out.println("我是main方法");
				
				Student s1 = new Student();
				Student s2 = new Student();
			}
		}

执行结果:
Demo2_Student静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法

(继承案例演示)(掌握)

  • A:继承(extends)
    • 让类与类之间产生关系,子父类关系
  • B:继承案例演示:
    • 动物类,猫类,狗类
    • 定义两个属性(颜色,腿的个数)两个功能(吃饭,睡觉)
  • C:案例演示
    • 使用继承前
  • D:案例演示
    • 使用继承后
class Demo1_Extends {
	public static void main(String[] args) {
		Cat c = new Cat();
		c.color = "花";
		c.leg = 4;
		c.eat();
		c.sleep();

		System.out.println(c.leg  + "..." + c.color);
	}
}

class Animal {
	String color;					//动物的颜色
	int leg;						//动物腿的个数

	public void eat() {				//吃饭的功能
		System.out.println("吃饭");
	}

	public void sleep() {			//睡觉的功能
		System.out.println("睡觉");
	}
}

class Cat extends Animal {
	
}

class Dog extends Animal {
	
}

/*
extends是继承的意思
Animal是父类
Cat和Dog都是子类
*/

(继承的好处和弊端)(掌握)

  • A:继承的好处
    • a:提高了代码的复用性
    • b:提高了代码的维护性
    • c:让类与类之间产生了关系,是多态的前提
  • B:继承的弊端
    • 类的耦合性增强了。
    • 开发的原则:高内聚,低耦合。
    • 耦合:类与类的关系
    • 内聚:就是自己完成某件事情的能力

(Java中类的继承特点)(掌握)

  • A:Java中类的继承特点
    • a:Java只支持单继承,不支持多继承。(一个儿子只能有一个爹)
      • 有些语言是支持多继承,格式:extends 类1,类2,…
    • b:Java支持多层继承(继承体系)
  • B:案例演示
    • Java中类的继承特点
      • 如果想用这个体系的所有功能用最底层的类创建对象
      • 如果想看这个体系的共性功能,看最顶层的类

(继承的注意事项和什么时候使用继承)(掌握)

  • A:继承的注意事项

    • a:子类只能继承父类所有非私有的成员(成员方法和成员变量)
    • b:子类不能继承父类的构造方法,但是可以通过super(马上讲)关键字去访问父类构造方法。
    • c:不要为了部分功能而去继承
    • 项目经理 姓名 工号 工资 奖金
    • 程序员 姓名 工号 工资
  • B:什么时候使用继承

    • 继承其实体现的是一种关系:“is a”。
      Person
      Student
      Teacher
      水果
      苹果
      香蕉
      橘子

    采用假设法。
    如果有两个类A,B。只有他们符合A是B的一种,或者B是A的一种,就可以考虑使用继承。

(继承中成员变量的关系)(掌握)

  • A:案例演示
    • a:不同名的变量
    • b:同名的变量
      • 子父类出现同名的变量只是在讲课中举例子有,在开发中是不会出现这种情况的
      • 子类继承父类就是为了使用父类的成员,那么如果定义了同名的成员变量没有意义了
class Demo4_Extends {
	public static void main(String[] args) {
		Son s = new Son();
		s.print();
	}
}

class Father {
	int num1 = 10;
	int num2 = 30;
}

class Son extends Father {
	int num2 = 20;

	public void print() {
		System.out.println(this.num1);				//this既可以调用本类的,也可以调用父类的(本类没有的情况下)
		System.out.println(this.num2);				//就近原则,子类有就不用父类的了
		System.out.println(super.num2);
	}
}

(this和super的区别和应用)(掌握)

  • A:this和super都代表什么
    • this:代表当前对象的引用,谁来调用我,我就代表谁
    • super:代表当前对象父类的引用
  • B:this和super的使用区别
    • a:调用成员变量
      • this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
      • super.成员变量 调用父类的成员变量
    • b:调用构造方法
      • this(…) 调用本类的构造方法
      • super(…) 调用父类的构造方法
    • c:调用成员方法
      • this.成员方法 调用本类的成员方法,也可以调用父类的方法
      • super.成员方法 调用父类的成员方法

(继承中构造方法的关系)(掌握)

  • A:案例演示
    • 子类中所有的构造方法默认都会访问父类中空参数的构造方法
  • B:为什么呢?
    • 因为子类会继承父类中的数据,可能还会使用父类的数据。

    • 所以,子类初始化之前,一定要先完成父类数据的初始化。

    • 其实:

      • 每一个构造方法的第一条语句默认都是:super() Object类最顶层的父类。
class Demo5_Extends {
	public static void main(String[] args) {
		Son s = new Son();
	}
}
 
class Father extends Object {
	public Father() {
		super();
		System.out.println("Father 的构造方法");
	}
}

class Son extends Father {
	public Son() {
		super();							//这是一条语句,如果不写,系统会默认加上,用来访问父类中的空参构造
		System.out.println("Son 的构造方法");
	}
}

(继承中构造方法的注意事项)(掌握)

  • A:案例演示
    • 父类没有无参构造方法,子类怎么办?
    • super解决
    • this解决
  • B:注意事项
    • super(…)或者this(….)必须出现在构造方法的第一条语句上,只能出现一个
class Demo6_Extends {
	public static void main(String[] args) {
		Son s1 = new Son();
		System.out.println(s1.getName() + "..." + s1.getAge());
		System.out.println("--------------------");
		Son s2 = new Son("张三",23);
		System.out.println(s2.getName() + "..." + s2.getAge());
	}
}

class Father {
	private String name;			//姓名
	private int age;				//年龄

	public Father() {				//空参构造
		System.out.println("Father 空参构造");
	}

	public Father(String name,int age) {	//有参构造
		this.name = name;
		this.age = age;
		System.out.println("Father 有参构造");
	}

	public void setName(String name) {	//设置姓名
		this.name = name;
	}

	public String getName() {			//获取姓名
		return name;
	}

	public void setAge(int age) {		//设置年龄
		this.age = age;
	}

	public int getAge() {				//获取年龄
		return age;
	}
}

class Son extends Father {
	public Son() {						//空参构造
		this("王五",25);				//本类中的构造方法
		//super("李四",24);				//调用父类中的构造方法
		
		System.out.println("Son 空参构造");
	}

	public Son(String name,int age) {	//有参构造
		super(name,age);
		System.out.println("Son 有参构造");
	}
}

(继承中的面试题)(掌握)

  • A:案例演示
  •   看程序写结果1
      class Fu{
      	public int num = 10;
      	public Fu(){
      		System.out.println("fu");
      	}
      }
      class Zi extends Fu{
      	public int num = 20;
      	public Zi(){
      		System.out.println("zi");
      	}
      	public void show(){
      		int num = 30;
      		System.out.println(num);
      		System.out.println(this.num);
      		System.out.println(super.num);
      	}
      }
      class Test1_Extends {
      	public static void main(String[] args) {
      		Zi z = new Zi();
      		z.show();
      	}
      } 
    
      看程序写结果2
      
      class Fu {
      	static {
      		System.out.println("静态代码块Fu");
      	}
    
      	{
      		System.out.println("构造代码块Fu");
      	}
    
      	public Fu() {
      		System.out.println("构造方法Fu");
      	}
      }
    
      class Zi extends Fu {
      	static {
      		System.out.println("静态代码块Zi");
      	}
    
      	{
      		System.out.println("构造代码块Zi");
      	}
    
      	public Zi() {
      		System.out.println("构造方法Zi");
      	}
      }
    
      Zi z = new Zi(); 请执行结果。
    

/*
1,jvm调用了main方法,main进栈
2,遇到Zi z = new Zi();会先将Fu.class和Zi.class分别加载进内存,再创建对象,当Fu.class加载进内存
父类的静态代码块会随着Fu.class一起加载,当Zi.class加载进内存,子类的静态代码块会随着Zi.class一起加载
第一个输出,静态代码块Fu,第二个输出静态代码块Zi
3,走Zi类的构造方法,因为java中是分层初始化的,先初始化父类,再初始化子类,所以先走的父类构造,但是在执行
父类构造时,发现父类有构造代码块,构造代码块是优先于构造方法执行的所以
第三个输出构造代码块Fu,第四个输出构造方法Fu
4,Fu类初始化结束,子类初始化,第五个输出的是构造代码块Zi,构造方法Zi
*/

(继承中成员方法关系)(掌握)

  • A:案例演示
    • a:不同名的方法
    • b:同名的方法

(方法重写概述及其应用)(掌握)

  • A:什么是方法重写
    • 重写:子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲)
  • B:方法重写的应用:
    • 当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法。这样,即沿袭了父类的功能,又定义了子类特有的内容。
  • C:案例演示
    • a:定义一个手机类。
class Demo7_Phone {
	public static void main(String[] args) {
		Ios8 i = new Ios8();
		i.siri();
		i.call();
	}
}

/*
B:方法重写的应用:
	* 当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法。这样,即沿袭了父类的功能,又定义了子类特有的内容。
	ios7系统 siri speak English
	ios8系统 siri 说中文
*/

class Ios7 {
	public void call() {
		System.out.println("打电话");
	}

	public void siri() {
		System.out.println("speak English");
	}
}

class Ios8 extends Ios7 {
	public void siri() {
		
		System.out.println("说中文");
		super.siri();
	}
}

(方法重写的注意事项)(掌握)

  • A:方法重写注意事项
    • a:父类中私有方法不能被重写

      • 因为父类私有方法子类根本就无法继承
    • b:子类重写父类方法时,访问权限不能更低

      • 最好就一致
    • c: 父类静态方法,子类也必须通过静态方法进行重写

      • 其实这个算不上方法重写,但是现象确实如此,至于为什么算不上方法重写,多态中我会讲解(静态只能覆盖静态)
    • 子类重写父类方法的时候,最好声明一模一样。

  • B:案例演示
    • 方法重写注意事项
class Demo8_双桨 {
	public static void main(String[] args) {
		DayOne d = new DayOne();
		d.泡妞();
		d.print();
	}
}
 
class 双桨 {
	public void sing() {
		System.out.println("唱红歌");
	}

	public void 泡妞() {
		System.out.println("唱红歌搞定林夕合鸟女士");
	}

	public static void print() {
		System.out.println("Fu print");
	}
}

class DayOne extends 双桨 {
	public void 泡妞() {
		System.out.println("霸王硬上弓");
	}

	public static void print() {				//静态只能覆盖静态,其实不算重写,多态时候详细讲解
		System.out.println("Zi print");
	}
}

(方法重写的面试题)(掌握)

  • A:方法重写的面试题
    • Override和Overload的区别?Overload能改变返回值类型吗?
      • overload可以改变返回值类型,只看参数列表

      • 方法重写:子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的

      • 方法重载:本类中出现的方法名一样,参数列表不同的方法。与返回值类型无关。

      • 子类对象调用方法的时候:

        • 先找子类本身,再找父类。

(使用继承前的学生和老师案例)(掌握)

  • A:案例演示
    • 使用继承前的学生和老师案例
    • 属性:姓名,年龄
    • 行为:吃饭
    • 老师有特有的方法:讲课
    • 学生有特有的方法:学习
class Test3_Person {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

class Student {
	private String name;					//姓名
	private int age;						//年龄

	public Student() {}						//空参构造

	public Student(String name,int age) {	//有参构造
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {		//设置姓名
		this.name = name;
	}

	public String getName() {				//获取姓名
		return name;
	}

	public void setAge(int age) {			//设置年龄
		this.age = age;
	}

	public int getAge() {					//获取年龄
		return age;
	}

	public void eat() {						//吃饭
		System.out.println("学生吃饭");
	}

	public void study() {					//学习
		System.out.println("学生学习");
	}
}

class Teacher {
	private String name;					//姓名
	private int age;						//年龄

	public Teacher() {}						//空参构造

	public Teacher(String name,int age) {	//有参构造
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {		//设置姓名
		this.name = name;
	}

	public String getName() {				//获取姓名
		return name;
	}

	public void setAge(int age) {			//设置年龄
		this.age = age;
	}

	public int getAge() {					//获取年龄
		return age;
	}

	public void eat() {						//吃饭
		System.out.println("老师吃饭");
	}

	public void teach() {					//学习
		System.out.println("老师讲课");
	}
}

(使用继承后的学生和老师案例)(掌握)

  • A:案例演示
    • 使用继承后的学生和老师案例
class Test4_Person {
	public static void main(String[] args) {
		Student s1 = new Student();
		s1.setName("张三");
		s1.setAge(23);
		System.out.println(s1.getName() + "..." + s1.getAge());
		s1.eat();
		s1.study();

		System.out.println("------------------");
		Student s2 = new Student("李四",24);
		System.out.println(s2.getName() + "..." + s2.getAge());
		s2.eat();
		s2.study();
	}
}
/*
* 使用继承后的学生和老师案例
*/

class Person {
	private String name;					//姓名
	private int age;						//年龄

	public Person() {}						//空参构造

	public Person(String name,int age) {	//有参构造
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {		//设置姓名
		this.name = name;
	}

	public String getName() {				//获取姓名
		return name;
	}

	public void setAge(int age) {			//设置年龄
		this.age = age;
	}

	public int getAge() {					//获取年龄
		return age;
	}

	public void eat() {						//吃饭
		System.out.println(name  + "吃饭");
	}
}

class Student extends Person {
	public Student() {}						//空参构造

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

	public void study() {
		System.out.println(this.getName() + "学习");
	}
}

class Teacher extends Person {
	public Teacher() {}						//空参构造

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

	public void teach() {
		System.out.println(this.getName() + "讲课");
	}
}

(猫狗案例分析,实现及测试)(掌握)

  • A:猫狗案例分析
  • B:案例演示
    • 猫狗案例继承版
    • 属性:毛的颜色,腿的个数
    • 行为:吃饭
    • 猫特有行为:抓老鼠catchMouse
    • 狗特有行为:看家lookHome

(final关键字修饰类,方法以及变量的特点)(掌握)

  • A:final概述
  • B:final修饰特点
    • 修饰类,类不能被继承
    • 修饰变量,变量就变成了常量,只能被赋值一次
    • 修饰方法,方法不能被重写
  • C:案例演示
    • final修饰特点
class Demo1_Final {
	public static void main(String[] args) {
		Son s = new Son();
		s.print();
	}
}

/*final class Father {
	public void print() {
		System.out.println("访问底层数据资源");
	}
}*/

class Son /*extends Father*/ {
	final int NUM = 10;						//常量命名规范,如果是一个单词,所有字母大写,如果是多个单词,每个单词都大写,中间用下划线隔开
	public static final double PI = 3.14;	//final修饰变量叫做常量,一般会与public static共用
	public void print() {
		//NUM = 20;
		System.out.println(NUM);
	}
}

(final关键字修饰局部变量)(掌握)

  • A:案例演示
    • 方法内部或者方法声明上都演示一下(了解)

    • 修饰基本类型,是值不能被改变

    • 修饰引用类型,是地址值不能被改变,对象中的属性可以改变

class Demo2_Final {
	public static void main(String[] args) {
		final int num = 10;
		//num = 20;
		System.out.println(num);

		final Person p = new Person("张三",23);
		//p = new Person("李四",24);
		p.setName("李四");
		p.setAge(24);

		System.out.println(p.getName() + "..." + p.getAge());

		method(10);
		method(20);
	}

	public static void method(final int x) {
		System.out.println(x);
	}
}

class Person {
	private String name;			//姓名
	private int age;				//年龄

	public Person(){}				//空参构造

	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public void setName(String name) {	//设置姓名
		this.name = name;
	}

	public String getName() {		//获取姓名
		return name;
	}

	public void setAge(int age) {	//设置年龄
		this.age = age;
	}

	public int getAge() {			//获取年龄
		return age;
	}
}

(final修饰变量的初始化时机)(掌握)

  • A:final修饰变量的初始化时机
    • 显示初始化
    • 在对象构造完毕前即可
class Demo3_Final {
	public static void main(String[] args) {
		Demo d = new Demo();
		d.print();
	}
}

class Demo {
	final int num;						//成员变量的默认初始化值是无效值
	
	public Demo() {
		num = 10;
	}
	public void print() {
		System.out.println(num);
	}
}

总结

1:代码块是什么?代码块的分类和各自特点?
2:静态代码块,构造代码块,构造方法的执行流程?
3:继承概述
4:继承的好处
5:Java中继承的特点
6:Java中继承的注意事项?以及我们什么时候使用继承?
7:继承中的成员访问特点
	A:成员变量
		在子类方法中访问一个变量
	B:成员方法
		在测试类中通过子类对象去访问一个方法
8:继承中构造方法的执行流程?假如父类没有无参构造方法,子类应该怎么办?
9:面试题:
	方法重写和方法重载的区别?方法重载能改变返回值类型吗?
	Overload
	Override

	this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。
10:继承案例练习
11:final关键字可以干什么?有什么特点?

12:final关键字的面试题?
	A:修饰局部变量
	B:初始化时机

(package关键字的概述及作用)(了解)

  • A:为什么要有包

    • 将字节码(.class)进行分类存放
    • 包其实就是文件夹
  • B:包的概述

  • 举例:
    学生:增加,删除,修改,查询
    老师:增加,删除,修改,查询

      方案1:按照功能分
      	com.heima.add
      		AddStudent
      		AddTeacher
      	com.heima.delete
      		DeleteStudent
      		DeleteTeacher
      	com.heima.update
      		UpdateStudent
      		UpdateTeacher
      	com.heima.find
      		FindStudent
      		FindTeacher
      
      方案2:按照模块分
      	com.heima.teacher
      		AddTeacher
      		DeleteTeacher
      		UpdateTeacher
      		FindTeacher
      	com.heima.student
      		AddStudent
      		DeleteStudent
      		UpdateStudent
      		FindStudent
    

(包的定义及注意事项)(掌握)

  • A:定义包的格式
    • package 包名;
    • 多级包用.分开即可
  • B:定义包的注意事项
    • A:package语句必须是程序的第一条可执行的代码
    • B:package语句在一个java文件中只能有一个
    • C:如果没有package,默认表示无包名

(带包的类编译和运行)(掌握)

  • A:如何编译运行带包的类
    • a:javac编译的时候带上-d即可
      • javac -d . HelloWorld.java
    • b:通过java命令执行。
      • java 包名.HellWord

(不同包下类之间的访问)(掌握)

  • A:案例演示
    • 不同包下类之间的访问
/*
* A:定义包的格式
	* package 包名;
	* 多级包用.分开即可
* B:定义包的注意事项
	* A:package语句必须是程序的第一条可执行的代码
	* B:package语句在一个java文件中只能有一个
	* C:如果没有package,默认表示无包名
*/
package com.heima;
import com.baidu.Person;
import com.xxx.Student;
//import java.util.Scanner;		//在开发中我们用的都是导入具体的类
import java.util.*;				//*代表通配符,他会到该包下挨个匹配,匹配上就导入
class Demo1_Package {
	public static void main(String[] args) {
		Person p = new Person("张三",23);
		System.out.println(p.getName() + "..." + p.getAge());
		//p.print();			//在不同包下的无关类,不允许访问,因为是protected修饰的

		/*Scanner sc = new Scanner(System.in);
		int x = sc.nextInt();
		System.out.println(x);*/
		
		Student s = new Student("李四",24);
		System.out.println(s.getName() + "..." + s.getAge());
		s.method();
	}
}

(import关键字的概述和使用)(掌握)

  • A:案例演示
    • 为什么要有import
      • 其实就是让有包的类对调用者可见,不用写全类名了
  • B:导包格式
    • import 包名;
    • 注意:
      • 这种方式导入是到类的名称。
      • 虽然可以最后写*,但是不建议。
  • C:package,import,class有没有顺序关系(面试题)

(四种权限修饰符的测试)(掌握)

  • A:案例演示
    • 四种权限修饰符
  • B:结论
  •   				本类	 同一个包下(子类和无关类)	           不同包下(子类)		不同包下(无关类)
      private 		Y		
      默认			Y					Y
      protected		Y					Y							Y
      public		Y					Y							Y						Y
    

(类及其组成所使用的常见修饰符)(掌握)

  • A:修饰符:

    • 权限修饰符:private,默认的,protected,public
    • 状态修饰符:static,final
    • 抽象修饰符:abstract
  • B:类:

    • 权限修饰符:默认修饰符,public

    • 状态修饰符:final

    • 抽象修饰符:abstract

    • 用的最多的就是:public

  • C:成员变量:

    • 权限修饰符:private,默认的,protected,public

    • 状态修饰符:static,final

    • 用的最多的就是:private

  • D:构造方法:

    • 权限修饰符:private,默认的,protected,public

    • 用的最多的就是:public

  • E:成员方法:

    • 权限修饰符:private,默认的,protected,public

    • 状态修饰符:static,final

    • 抽象修饰符:abstract

    • 用的最多的就是:public

  • F:除此以外的组合规则:

    • 成员变量:public static final
    • 成员方法:
      • public static
      • public abstract
      • public final

(内部类概述和访问特点)(了解)

  • A:内部类概述
  • B:内部类访问特点
    • a:内部类可以直接访问外部类的成员,包括私有。
    • b:外部类要访问内部类的成员,必须创建对象。
    • 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
  • C:案例演示
    • 内部类极其访问特点
class Demo1_InnerClass {
	public static void main(String[] args) {
		//Inner i = new Inner();
		//i.method();
		//外部类名.内部类名 = 外部类对象.内部类对象
		Outer.Inner oi = new Outer().new Inner();			//创建内部类对象
		oi.method();

	}
}


class Outer {
	private int num = 10;
	class Inner {
		public void method() {
			System.out.println(num);
		}
	}
}

(成员内部类私有使用)(了解)

  • private
    • 提供公共的访问方式
class Demo2_InnerClass {
	public static void main(String[] args) {
		//Outer.Inner oi = new Outer().new Inner();
		//oi.method();

		Outer o = new Outer();
		o.print();
	}
}

class Outer {
	private int num = 10;
	private class Inner {
		public void method() {
			System.out.println(num);
		}
	}

	public void print() {
		Inner i = new Inner();
		i.method();
	}
}

(静态成员内部类)(了解)

  • static
  • B:成员内部类被静态修饰后的访问方式是:
    • 外部类名.内部类名 对象名 = 外部类名.内部类对象;
class Demo1_InnerClass {
	public static void main(String[] args) {
		//外部类名.内部类名 对象名 = 外部类名.内部类对象;
		Outer.Inner oi = new Outer.Inner();
		oi.method();

		Outer.Inner2.print();
	}
}

class Outer {
	static class Inner {
		public void method() {
			System.out.println("method");
		}
	}

	static class Inner2 {
		public static void print() {
			System.out.println("print");
		}
	}
}

(成员内部类的面试题)(掌握)

  • A:面试题
  •   要求:使用已知的变量,在控制台输出30,20,10。
      
      class Outer {
      	public int num = 10;
      	class Inner {
      		public int num = 20;
      		public void show() {
      			int num = 30;
      			System.out.println(?);
      			System.out.println(??);
      			System.out.println(???);
      		}
      	}
      }
      class InnerClassTest {
      	public static void main(String[] args) {
      		Outer.Inner oi = new Outer().new Inner();
      		oi.show();
      	}	
      }
    
class Test1_InnerClass {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}
//要求:使用已知的变量,在控制台输出30,20,10。
//内部类之所以能获取到外部类的成员,是因为他能获取到外部类的引用外部类名.this
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(Outer.this.num);
		}
	}
}

(局部内部类访问局部变量的问题)(掌握)

  • A:案例演示
    • 局部内部类访问局部变量必须用final修饰
    • 局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
      因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
      但是jdk1.8取消了这个事情,所以我认为这是个bug
class Demo1_InnerClass {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}
//局部内部类
class Outer {
	public void method() {
		final int num = 10;
		class Inner {
			public void print() {
				System.out.println(num);
			}
		}

		Inner i = new Inner();
		i.print();
	}

	/*public void run() {
		Inner i = new Inner();				//局部内部类,只能在其所在的方法中访问
		i.print();
	}*/
}

(匿名内部类的格式和理解)

  • A:匿名内部类
    • 就是内部类的简化写法。
  • B:前提:存在一个类或者接口
    • 这里的类可以是具体类也可以是抽象类。
  • C:格式:
  •   new 类名或者接口名(){
      	重写方法;
      }
    
  • D:本质是什么呢?
    • 是一个继承了该类或者实现了该接口的子类匿名对象。
  • E:案例演示
    • 按照要求来一个匿名内部类
class Demo1_NoNameInnerClass {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

interface Inter {
	public void print();
}

class Outer {
	class Inner implements Inter {
		public void print() {
			System.out.println("print");
		}
	}

	public void method(){
		//Inner i = new Inner();
		//i.print();
		//new Inner().print();
		//Inter i = new Inner();			//父类引用指向子类对象
		
		new Inter() {						//实现Inter接口
			public void print() {			//重写抽象方法
				System.out.println("print");
			}
		}.print();
	}
}

(匿名内部类重写多个方法调用)

  • A:案例演示
    • 匿名内部类的方法调用
class Demo2_NoNameInnerClass {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

interface Inter {
	public void show1();
	public void show2();
}
//匿名内部类只针对重写一个方法时候使用
class Outer {
	public void method() {
		/*new Inter(){
			public void show1() {
				System.out.println("show1");
			}

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

		new Inter(){
			public void show1() {
				System.out.println("show1");
			}

			public void show2() {
				System.out.println("show2");
			}
		}.show2();*/

		Inter i = new Inter(){
			public void show1() {
				System.out.println("show1");
			}

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

			/*public void show3() {
				System.out.println("show3");
			}*/
		};

		i.show1();
		i.show2();
		//i.show3();						//匿名内部类是不能向下转型的,因为没有子类类名
	}
}

(匿名内部类在开发中的应用)

  • A:代码如下
  •   //这里写抽象类,接口都行
      abstract class Person {
      	public abstract void show();
      }
    
      class PersonDemo {
      	public void method(Person p) {
      		p.show();
      	}
      }
    
      class PersonTest {
      	public static void main(String[] args) {
      		//如何调用PersonDemo中的method方法呢?
      		PersonDemo pd = new PersonDemo ();
      		
      	}
      }
    
class Test1_NoNameInnerClass {
	public static void main(String[] args) {
		//如何调用PersonDemo中的method方法呢?
		PersonDemo pd = new PersonDemo ();
		//pd.method(new Student());
		pd.method(new Person() {
			public void show() {
				System.out.println("show");
			}
		});
	}
}
//这里写抽象类,接口都行
abstract class Person {
	public abstract void show();
}

class PersonDemo {
	
	//public void method(Person p) {		//Person p = new Student();		//父类引用指向子类对象
	/*
	Person p = new Person(){
		public void show() {
			System.out.println("show");
		}
	};
	*/
	public void method(Person p) {
		p.show();
	}
}

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

(匿名内部类的面试题)

  • A:面试题
  •   按照要求,补齐代码
      interface Inter { void show(); }
      class Outer { //补齐代码 }
      class OuterDemo {
      	public static void main(String[] args) {
      		  Outer.method().show();
      	  }
      }
      要求在控制台输出”HelloWorld”
    
class Test2_NoNameInnerClass {
	public static void main(String[] args) {
		//Outer.method().show();			//链式编程,每次调用方法后还能继续调用方法,证明调用方法返回的是对象
		Inter i = Outer.method();
		i.show();
	}
}
//按照要求,补齐代码
//要求在控制台输出”HelloWorld”
interface Inter { 
	void show(); 
}

class Outer { 
	//补齐代码 
	public static Inter method() {
		return new Inter() {
			public void show() {
				System.out.println("HelloWorld");
			}
		};
	}
}


你可能感兴趣的:(Java基础)