面向对象_4

最新推荐文章于 2022-05-26 22:17:21 发布

故意的是吧

最新推荐文章于 2022-05-26 22:17:21 发布

阅读量318

点赞数

分类专栏： JAVA

JAVA 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

1:形式参数和返回值的问题(理解)

(1)形式参数：

类名：需要该类的对象

抽象类名：需要该类的子类对象

接口名：需要该接口的实现类对象

(2)返回值类型：

类名：返回的是该类的对象

抽象类名：返回的是该类的子类对象

接口名：返回的是该接口的实现类的对象

(3)链式编程

对象.方法1().方法2().......方法n();

这种用法：其实在方法1()调用完毕后，应该一个对象；

方法2()调用完毕后，应该返回一个对象。

方法n()调用完毕后，可能是对象，也可以不是对象。

2:包(理解)

(1)其实就是文件夹

(2)作用：

A:区分同名的类

B:对类进行分类管理

a:按照功能分

b:按照模块分

(3)包的定义(掌握)

package 包名;

多级包用.分开。

(4)注意事项：(掌握)

A:package语句必须在文件中的第一条有效语句

B:在一个java文件中，只能有一个package

C:如果没有package，默认就是无包名

(5)带包的编译和运行

A:手动式

B:自动式(掌握)

javac -d . HelloWorld.java

3:导包(掌握)

(1)我们多次使用一个带包的类，非常的麻烦，这个时候，Java就提供了一个关键字import。

(2)格式：

import 包名...类名;

另一种：

import 包名...*;(不建议)

(3)package,import,class的顺序

package > import > class

4:权限修饰符(掌握)

(1)权限修饰符

本类同一个包下不同包下的子类不同包下的无关类

privateY

默认YY

protectedYYY

publicYYYY

(2)这四种权限修饰符在任意时刻只能出现一种。

public class Demo {}

5:常见的修饰符(理解)

(1)分类：

权限修饰符：private,默认,protected,public

状态修饰符：static,final

抽象修饰符：abstract

(2)常见的类及其组成的修饰

类：

默认,public,final,abstract

常用的：public

成员变量：

private,默认,protected,public,static,final

常用的：private

构造方法：

private,默认,protected,public

常用的：public

成员方法：

private,默认,protected,public,static,final,abstract

常用的：public

(3)另外比较常见的：

public static final int X = 10;

public static void show() {}

public final void show() {}

public abstract void show();

6:内部类(理解)

(1)把类定义在另一个类的内部，该类就被称为内部类。

举例：把类B定义在类A中，类B就被称为内部类。

(2)内部类的访问规则

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

B:外部类要想访问内部类成员，必须创建对象

(3)内部类的分类

A:成员内部类

B:局部内部类

(4)成员内部类

A:private 为了数据的安全性

B:static 为了访问的方便性

成员内部类不是静态的：

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

成员内部类是静态的：

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

(5)成员内部类的面试题(填空)

30,20,10

class Outer {

public int num = 10;

class Inner {

public int num = 20;

public viod show() {

int num = 30;

System.out.println(num);

System.out.println(this.num);

System.out.println(Outer.this.num);

}

(6)局部内部类

A:可以直接访问外部类的成员

B:在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能

A:局部内部类访问局部变量必须加final修饰。

B:为什么呢?

因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。

所以，堆内存还是用该变量，而改变量已经没有了。

为了让该值还存在，就加final修饰。

通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。

(7)匿名内部类(掌握)

A:是局部内部类的简化形式

B:前提

存在一个类或者接口

C:格式:

new 类名或者接口名() {

重写方法;

}

D:本质：

其实是继承该类或者实现接口的子类匿名对象

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

我们在开发的时候，会看到抽象类，或者接口作为参数。

而这个时候，我们知道实际需要的是一个子类对象。

如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

interface Person {

public abstract void study();

}

class PersonDemo {

public void method(Person p) {

p.study();

}

class PersonTest {

public static void main(String[] args) {

PersonDemo pd = new PersonDemo();

pd.method(new Person() {

public void study() {

System.out.println("好好学习，天天向上");

}

});

}

(9)匿名内部类的面试题(补齐代码)

interface Inter {

void show();

}

class Outer {

//补齐代码

public static Inter method() {

return new Inter() {

public void show() {

System.out.println("HelloWorld");

}

};

}

class OuterDemo {

public static void main(String[] args) {

Outer.method().show(); //"HelloWorld"

}

###########################################################################################

1:形式参数和返回值问题

形式参数

基本类型

引用类型

返回值类型

基本类型

引用类型

2:包的定义及注意事项

package

第一条有效语句

唯一

3:导包及注意事项

import

java.lang不需要导入

java.xxx.yyy.类名; 导入到类的级别

java.xxx.yyy.*; 这个也可以，但是不建议

4:四种权限修饰符及其特点

本类中同一个包下不同包下的子类不同包下的无关类

privateY

默认YY

protectedYYY

publicYYYY

5:常见的修饰符及组合

类：public

成员变量：private

构造方法：public

成员方法：public

6:内部类的概述及访问特点

把类定义在另一个类的内部，叫内部类。

访问特点：

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

外部类访问内部类的成员需要创建对象

7:内部类的分类

按照位置不同

成员内部类成员位置

成员内部类的修饰符：

private 为了保证数据的安全性

static 为了方便访问数据

注意：静态内部类访问的外部类数据必须用静态修饰。

//成员内部类被静态修饰后的访问方式是:

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

Outer.Inner oi = new Outer.Inner();

局部内部类局部定义，例如外部类成员方法内

8:匿名内部类的格式和应用及面试题

new 类名或者接口名() {

重写方法;

}

###########################################################################################

抽象类做形参

//不报错，但因为还没有具体类还无法使用
abstract class Person{
	
	public abstract void study();
}
class PersonDemo{
	//抽象方法的形参是抽象类时，实际需要的是子类
	public void method(Person p){
		p.study();
	}
}
//创建具体子类后即可使用
class Student extends Person{
	public void study(){
		System.out.println("好好学习，天天向上");
	}
}
public class ZuoYe {
	public static void main(String[] args) {
		PersonDemo pd=new PersonDemo();
		//传入一个匿名子类
		pd.method(new Student());
		Person p=new Student();
		p.study();
	}		
}

输出：

好好学习，天天向上

接口做形参

interface Study{
	public abstract void study();
}

class Person{
	public void method(Study s){
		s.study();
	}
}
class Student implements Study{
	public void study(){
		System.out.println("老师学教书");
	}
}
public class ZuoYe {
	public static void main(String[] args) {
		Person p=new Person();
		p.method(new Student());
		//利用多态实现接口
		Study s=new Student();
		p.method(s);
		Student st=new Student();
		p.method(st);
	}		
}

输出：

老师学教书

类名做返回类型

//类名做返回值类型
//返回的是该类的对象
class Student{
	public void study(){
		System.out.println("好好学习，天天向上");
	}
}
class Student2{
	public Student getStudent(){
		//匿名对象直接返回
		return new Student();
	}
}
public class ZuoYe {
	public static void main(String[] args) {
		Student2 s=new Student2();
		Student ss=s.getStudent();//s.getStudent() 返回的就是new Student()
		ss.study();
	}		
}

输出：

好好学习，天天向上

抽象类做返回类型

//抽象类名做返回值类型
//返回的是该类子类的对象
abstract class Person{
	public abstract void study();
}
class Student extends Person{
	public void study(){
		System.out.println("该学习了");
	}
}
class PersonDemo{
	public Person getPerson(){
		//返回的是抽象类的子类对象
		return new Student();
	}
}
public class ZuoYe {
	public static void main(String[] args) {
		PersonDemo pd=new PersonDemo();
		Person p=pd.getPerson();//相当于 Person p=new Student()
		p.study();
	}		
}

输出：

该学习了

接口做返回类型

//接口做返回值类型
//返回的是该接口的实现类的对象
interface Study{
	public abstract void study();
}
class StudyDemo{
	public Study getStudy(){
		return new Teacher();
	}
}
class Teacher implements Study{
	public void study(){
		System.out.println("学会讲课了");
	}
}
public class ZuoYe {
	public static void main(String[] args) {
		StudyDemo sd=new StudyDemo();
		Study s=sd.getStudy();//相当于 Study s=new Teacher()
		s.study();
		//链式编程
		//每次调用完方法，返回的是一个对象
		sd.getStudy().study();
	}		
}

输出：

学会讲课了

匿名内部类

/*
	匿名内部类面试题：
		按照要求，补齐代码
			interface Inter { void show(); }
			class Outer { //补齐代码 }
			class OuterDemo {
				public static void main(String[] args) {
					  Outer.method().show();
				  }
			}
			要求在控制台输出”HelloWorld”
*/
interface Inter { 
	void show(); 
	//public abstract
}

class Outer { 
	//补齐代码
	public static Inter method() {
		//子类对象 -- 子类匿名对象
		return new Inter() {
			public void show() {
				System.out.println("HelloWorld");
			}
		};
	}
}

class OuterDemo {
	public static void main(String[] args) {
		Outer.method().show();
		/*
			1:Outer.method()可以看出method()应该是Outer中的一个静态方法。
			2:Outer.method().show()可以看出method()方法的返回值是一个对象。
				又由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口。
		*/
	}
}

故意的是吧

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象_4

1:形式参数和返回值的问题(理解)(1)形式参数：类名：需要该类的对象抽象类名：需要该类的子类对象接口名：需要该接口的实现类对象(2)返回值类型：类名：返回的是该类的对象抽象类名：返回的是该类的子类对象接口名：返回的是该接口的实现类的对象(3)链式编程对象.方法1().方法2().......方法n();
复制链接

扫一扫