面向对象5

最新推荐文章于 2024-10-17 10:27:13 发布

王小年.

最新推荐文章于 2024-10-17 10:27:13 发布

阅读量154

点赞数

文章标签： java

本文链接：https://blog.csdn.net/wangxiaonian666/article/details/117561542

版权

文章目录

一、方法参数类型以及返回值类型问题研究
二、权限修饰符
- 1.四种权限修饰符的测试
- 2.类及其组成所使用的常见修饰符
三、内部类

一、方法参数类型以及返回值类型问题研究

类名作为形式参数
当你以后看到一个方法的形参要一个类类型，你就传递一个该类的对象。

抽象类名作为形式参数
当你以后看到一个方法的形参要一个抽象类类型，你就传递一个该抽象类的子类对象。

接口名作为形式参数
当你以后看到一个方法的形参要一个接口类型，你就传递一个该接口的子类对象。

类名作为返回值类型
当你以后看到一个方法的返回值类型，是一个类类型，你就返回一个该类的对象。

抽象类名作为返回值类型
当你以后看到一个方法的返回值类型是一个抽象类类型，你就返回一个该抽象类的子类对象。

接口名作为返回值类型
当你以后看到一个方法的返回值类型是一个接口类型，你就返回一个该接口的子类对象

链式编程

//链式编程风格
 //当你调用完一个方法，这个方法的返回值是个对象，那么你可以继续打点，调用该对象中的方法。
 int num = new Student().getStudent(new Student(), 800).getStudent(new Student(), 9000).getNum();

package关键字的概述及作用

A:包的概述: 就是文件夹
B:包的作用: 用来解决同一个路径下不能存在同名文件的问题(分类管理)
C:包的划分:
按照功能
按照模块
D:定义包的格式
package 包名;
多级包用.分开即可
E:定义包的注意事项
a:package语句必须是程序的第一条可执行的代码
b:package语句在一个java文件中只能有一个
c:如果没有package，默认表示无包名

import关键字的概述和使用

A:导包的概述
不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能
B:导包格式
import 包名;
注意：
这种方式导入是到类的名称。
虽然可以最后写*，但是不建议。
C:package,import,class有没有顺序关系(面试题)
有关系,package > import > class
1、 package 只能有一个，必须放在java文件的第一行,
2、 import 只能放在 package 的下面,可以有多个，多个 import 应放在一起,
3、而 class 放在 package 或者import的下面，可以有多个，建议一个

二、权限修饰符

1.四种权限修饰符的测试

四种权限修饰符: private(私有的) , 默认 , protected(受保护的) , public(公共的)
结论
本类同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y

2.类及其组成所使用的常见修饰符

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

三、内部类

1. 内部类概述和访问特点

A:内部类概述: 把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义了一个类B，类B就是内部类。
B:内部类访问特点
a:内部类可以直接访问外部类的成员，包括私有。
b:外部类要访问内部类的成员，必须创建对象。

2.内部类分类及成员内部类的直接使用

A:按照内部类位置分类
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。
B:成员内部类
如何在测试类中直接访问内部类的成员。
格式: 外部类名.内部类名对象名 = 外部类对象.内部类对象;

3.成员内部类的常见修饰符及应用

A:成员内部类的修饰符：
private 为了保证数据的安全性
static 为了方便访问数据
注意事项: a:静态内部类访问的外部类数据必须用静态修饰。
b: 成员方法可以是静态的也可以是非静态的。
B:成员内部类被静态修饰后的访问方式是:
格式: 外部类名.内部类名对象名 = new 外部类名.内部类名();

4.成员内部类的面试题

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(num); //30 
				System.out.println(this.num); //20
				System.out.println(Outer.this.num); //10
			}
		}
	}
	class InnerClassTest {
		public static void main(String[] args) {
			Outer.Inner oi = new Outer().new Inner();
			oi.show();
		}	
	}

5.局部内部类访问局部变量的问题

A: 可以直接访问外部类的成员
B: 可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
C:局部内部类访问局部变量必须用final修饰
为什么呢?
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
为了让数据还能继续被使用，就用final修饰，这样，在堆内存里面存储的其实是一个常量值。
JDK1.8之后，final会默认加上，不用手动去加

lass Oueter {

    public void show(final int a, final int b) {
        //局部变量
        final int num = 20;
        //局部内部类访问外部类的局部变量，局部变量必须用final修饰，使其变为常量。JDK1.8 这个final默认就加上了。
        class Inner {
            public void neiShow() {
                System.out.println(num);
                System.out.println(a);
                System.out.println(b);
            }
        }
    }
}

6.匿名内部类

A:匿名内部类: 就是局部内部类的简化写法。
B:前提：存在一个类或者接口;这里的类可以是具体类也可以是抽象类。
C:格式：
new 类名或者接口名(){
重写方法;
} ;
D:本质是什么呢?
是一个继承了该类或者实现了该接口的子类匿名对象。

7.匿名内部类在开发中的应用

A:问题引出
首先回顾我们曾经讲过的方法的形式参数是引用类型的情况，
我们知道这里需要一个子类对象。而匿名内部类就是一个子类匿名对象，
所以，可以使用匿名内部类改进以前的做法。
B:代码如下

//这里写抽象类，接口都行
	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 personDemo=new PersonDemo();
                personDemo.method(new Person(){
                     public void show(){
                       sout.("fdfds");
                     }
                });
			}
		}

8.匿名内部类中this关键字

A: 面试题

interface Inter {
		public static final int a = 23 ;
	}
	
	public class Test {

		public static void main(String[] args) {
			new Inter() {
			    // int a=20;//此时输出的就是20
				public void show() {
					//this 代表匿名内部类
					System.out.println(this.a);//23
		
				}
			}.show();
		}
	}

9.匿名内部类的面试题

A:面试题
	按照要求，补齐代码
	interface Inter { 
		void show(); 
	}
	
	class Outer { 
		//补齐代码 
		public static Inter method(){
		     return new Inter(){
		     public void show(){sout.("HelloWorld");}
		     };
		}
	}
	
	class OuterDemo {
		public static void main(String[] args) {
			  Outer.method().show();// 可以通过类直接调用这个方法说明这个方法是静态的
		  }
	}
	要求在控制台输出”HelloWorld”