面向对象（七）

一、类名作为形式参数

形式参数:

基本类型（太简单）

引用类型

类（匿名对象的时候其实我们已经讲过了）需要的是该类的对象

抽象类:需要的是该抽象的类子类对象

接口：跟接口很相似，需要的是该接口的实现类对象。

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("Good Good Study,Day Day Up");
}
}

class PersonTest{
public static void main(String[] args){
/*
目前是没有办法使用的
因为抽象类没有对应的具体类
那么，我们就应该先定义一个具体类
需求：我要使用persondemo类中的method方法
*/
PersonDemo pd = new PersonDemo();
Person p = new Student();//多态
pd.method(p);
}
}

//  定义一个爱好的接口
interface Love{
public abstract void love();

}

class LoveDemo{
public void method(Love l){
l.love();
}
}

//定义具体类实现接口
class Teacher implements Love{
System.out.println("老师爱学生，爱java，爱周秀蓉");
}

class TeacherTest{
public static void main(String[] args){
LoveDemo ld = new LoveDemo();
Love l = new Teacher();
ld.method(l);
}
}

二、类名作为返回值类型

返回值类型

基本类型：太简单

引用类型：

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

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

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

class Student{
public void study(){
System.out.println("Good Good Study,Day Day Up");
}
}

class StudentDemo{
public Student method(){
return new Student();
}
}

class ClassDemo{
public static void main(String[] args){
//需求：调用Student中的study方法
//但是不直接创建对象调用，而是通过StudentDemo调用
StudentDemo sd  = new StudentDemo();
Student s = sd.method();
s.study();
}
}

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

class PersonDemo{
public Person method(){
//Person p = new Student();
//return p;
return new Student();
}
}

class Student extends Person{
public void study(){
System.out.println("Good Good Study,Day Day Up");
}
}

class PersonTest{
public static void main(String[] args){

PersonDemo pd = new PersonDemo();
Person p = pd.method();
p.study();
}
}

//  定义一个爱好的接口
interface Love{
public abstract void love();

}

class LoveDemo{
public Love method(){
//Love l = new Teacher();
//return l;
return new Teacher();
}
}

//定义具体类实现接口
class Teacher implements Love{
public void love(){
System.out.println("老师爱学生，爱java，爱周秀蓉");
}
}

class TeacherTest{
public static void main(String[] args){

LoveDemo ld = new LoveDemo();
Love l = ld.method();
l.love();
}
}

三、链式编程

/*
链式编程：
每次调用完毕方法后，返回的是一个对象。
*/

class Student{
public void study(){
System.out.println("Good Good Study,Day Day Up");
}
}

class StudentDemo{
public Student method(){
return new Student();
}
}

class StudentTest{
public static void main(String[] args){
StudentDemo sd = new StudentDemo();
//Student s = sd.method();
//s.study();

//注意了
//现象：对象调方法，再调方法，再调方法
sd.method().study();

}
}

四、package关键字

1.概述

/*
包：
A:其实就是文件夹
B:作用
a:把相同的类名放到不同的包中
b:对类进行分类管理
举例：
学生：增加，删除，修改，查询
老师：增加，删除，修改，查询
...

分包的方案：
方案1：按照功能分
cn.jkx.add
AddStudent
AddTeacher
cn.jkx.delete
DeleteStudent
AddTeacher
cn.jkx.update
UpdateStudent
AddTeacher
cn.jkx.find
FindStudent
FindTeacher

方案2：按照模块分
cn.jkx.teacher
AddTeacher
AddTeacher
AddTeacher
FindTeacher
cn.jkx.student
AddStudent
DeleteStudent
UpdateStudent
FindStudent
*/

2.包的定义

/*
包的定义：
package 包名；
多级包用.分开即可
package cn.jkx.student

包的注意事项：
A:package语句必须是程序的第一条可执行的代码
B:package语句在一个java文件中只能有一个
C:如果没有package，默认表示无包名
*/

五、import关键字

/*
导包：
格式：import 包名;
这种方式导入时到类的名称；
注意：我们用哪个类就导入哪个类，
不要导入*

面试题：
package，import，class有没有顺序关系

package > import > class

package:只能有一个
import:可以有多个
class:可以有多个，以后建议是一个

*/
import com.yangb.Demo;

六、四种权限修饰符

权限修饰符:

本类中 同一个包下（包含子类和无关类） 不同包下（子类） 不同包下（无关类）

private Y N N N

默认 Y Y N N

protected Y Y Y N

public Y Y Y Y

七、内部类的概述和访问特点

1.内部类概述：

把类定义在其他类的内部，这个类就被称为内部类。

举例：在类A中定义一个类B，类B就是内部类。

内部类的访问特点：

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

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

class Outer{

private int num = 10;

class Inear{
public void show(){
System.out.println(num);
}
}

public void method(){
//找不到符号
//show();
Inear i = new Inear();
i.show();
}
}

class InearClassDemo{
public static void main(String[] args){

}
}

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

内部类的位置

成员位置：在成员位置定义的类，被称为成员内部类。

局部位置：在局部位置定义的类，被称为局部内部类。

class Outer{
private int num = 10;

//成员位置
class Inner{

}
/*
public void method(){
class Inner{

}
}
*/
}
class InnerClassDemo{
public static void main(String[] args){

}
}

成员内部类：

如何直接访问内部类的成员。

外部类名.内部类名 对象名 = 外部类对象.内部类对象

class Outer{
private int num = 10;

class Inner{
public void show(){
System.out.println(num);
}
}
}

class InnerClassDemo2{
public static void main(String[] args){
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}

成员内部类的修饰符：

private：为了保证数据的安全性

static：为了方便访问数据

注意：静态内部类访问的外部类的数据只能是static修饰的。

案例：我有一个人，人有身体，身体内有心脏。

class Body{
private class Heart{
public void operator(){
System.out.println("心脏搭桥");
}
}

public void method(){
if(如果你是外科医生){
Heart h = new Heart();
h.operator();
}
}
}

按照我们刚才的讲解，来使用一下
Body.Heart bh = new Body().new Heart();
bh.operator();
//加了private后，就不能被直接访问了。
Body b = new Body();
b.method();

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

//内部类用静态修饰是因为内部类可以看成是外部类的成员。
public static class Inner{
public void show(){
//错误: 无法从静态上下文中引用非静态 变量 num
//System.out.println(num);
System.out.println(num2);
//静态内部类中访问的外部类的数据只能是静态修饰的。
}

public static void show2(){
//System.out.println(num);
System.out.println(num2);
}
}
}

class InnerClassDemo3{
public static void main(String[] args){
//使用内部类
//Outer.Inner oi = new Outer().new Inner();
//oi.show();
//oi.show2();

//成员内部类被静态修饰后的访问方式是：
//格式：外部类名.内部类名  对象名 = new 外部内名.内部类名（）；
Outer.Inner oi = new Outer.Inner();
oi.show();
oi.show2();

//show2的另一种调用方式
Outer.Inner.show2();
}
}

3.成员内部类的面试题

要求分别输出30,20,10，请填空

注意：
1.内部类和外部类没有继承关系
2.通过外部类名限定this对象
Outer.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(new Outer.num);
System.out.println(Outer.this.num);
}
}
}

class InnerClassTest{
public static void main(String[] args){
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}

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

局部内部类

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

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

面试题：

局部内部类访问局部变量的注意事项：

A；局部内部类访问局部变量必须用final修饰

为什么呢？

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

而堆内存的内容并不会立即消失，所以，我们加final修饰。

加入final修饰后，这个变量就成了常量。既然是常量，你消失了

我再内存中存储的是数据20，所以，我还是有数据在使用。

class Outer{
private int num = 10;

public void method(){
final int num2 = 20;
class Inner{
public void show(){
System.out.println(num);
//错误: 从内部类中访问本地变量num2; 需要被声明为最终类型
System.out.println(num2);//20

}
}

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

class InnerClassDemo{
public static void main(String[] args){
Outer o = new Outer();
o.method();
}
}

5.匿名内部类的格式和理解

匿名内部类

就是内部类的简化写法

前提：存在一个类或者接口

这里的类可以是具体类也可以是抽象类。

格式：
new 类名或者接口名(){
重写方法；
};

本质是什么呢？
是一个继承了该类或者实现了该接口的子类匿名对象。

interface Inter{
public abstract void show();
public abstract void show2();
}

class Outer{
public void method(){
//一个方法的时候
/*
new Inter(){
public void show(){
System.out.println("show");
}
}.show();*/

//两个方法的时候
/*
new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
}.show();

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

//如果我是很多个方法，就很麻烦了
//那么，有没有改进的方案呢？
Inter i = new Inter(){//多态
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
};

i.show();
i.show2();
}
}

class InnerClassDemo{
public static void main(String[] args){
Outer o = new Outer();
o.method();

}
}

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

interface Person{
public abstract void study();
}

class PersonDemo{
//接口名作为形式参数
//其实这里需要的不是接口，而是接口的实现类
public void method(Person p){
p.study();
}
}

//实现类
class Student implements Person{
public void study(){
System.out.println("好好学习，天天向上");
}
}

class InnerClassDemoTest{
public static void main(String[] args){
PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method(p);
System.out.println("--------------");

//匿名内部类在开发中的使用
//匿名内部类的本质是继承类或者实现了接口的子类匿名对象
pd.method(new Person(){
public void study(){
System.out.println("好好学习，天天向上");
}
});
}
}

7.匿名内部类面试题

按照要求，补齐代码
interface Inter{
void show();
}
class Outer{//补齐代码}
class OuterDemo{
public static void main(String[] args){
Outer.method().show();
}
}

//要求在控制台输出“hello world”

interface Inter{
void show();
//public abstract
}

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

}
}

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

七、Myeclipse工具的使用

1:Eclipse的安装

2:用Eclipse写一个HelloWorld案例，最终在控制台输出你的名字

A:创建项目
B:在src目录下创建包。cn.itcast
C:在cn.itcast包下创建类。HelloWorld
D:在HelloWorld下有一个方法。public static void main(String[] args) {}
E:在main方法中有一个输出语句。System.out.println("你的名字");

3:Eclipse空间的基本配置

A:程序的编译和运行的环境配置(一般不改)

window – Preferences – Java

编译环境：Compiler 默认选中的就是最高版本。

运行环境：Installed JREs 默认会找你安装的那个JDK。建议配置了Java的环境变量。

问题：

低编译，高运行。可以。

高编译，低运行。不可以。

建议，编译和运行的版本一致。

B:如何去掉默认注释?
window -- Preferences -- Java -- Code Style -- Code Templates
选择你不想要的内容，通过右边Edit编辑。
注意：请只删除注释部分，不是注释部分的不要删除。

C:行号的显示和隐藏
显示：在代码区域的最左边的空白区域，右键 -- Show Line Numbers即可。
隐藏：把上面的动作再做一次。

D:字体大小及颜色
a:Java代码区域的字体大小和颜色：
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Java修改 -- Java Edit Text Font
b:控制台
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font
c:其他文件
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font

E:窗体给弄乱了，怎么办?
window -- Reset Perspective

F:控制台找不到了，怎么办?
Window--Show View—Console

4:常用快捷键

A:格式化 ctrl+shift+f

B:导入包 ctrl+shift+o

如果该类仅仅在一个包中有，就自己显示了

如果该类在多个包中有，会弹出一个框框供你选择

C:注释

单行：注释 ctrl+/，取消注释再来一次。

多行：ctrl+shift+/,ctrl+shift+\

D:代码上下移动

选中代码alt+上/下箭头

E:查看源码

选中类名(F3或者Ctrl+鼠标点击)

5:如何提高开发效率

A:自动生成构造方法

a:无参构造方法 在代码区域右键–source–Generate Constructors from Superclass

b:带参构造方法 在代码区域右键–source–Generate Constructors using fields.. – finish

B:自动生成getXxx()/setXxx()方法

在代码区域右键–source–Generate Getters and Setters…

提供了对应的快捷键操作。
alt+shift+s
按下带有下划线的那个字母即可。

C:如何继承抽象类和实现接口。
D:Override的作用
表示该方法是重写父类的。如果方法声明和父类不匹配，就会报错。

6:通过讲解的快捷键和提高开发效率的一些内容完成如下内容

自定义学生类:Student

成员变量；

姓名

年龄

构造方法：

无参

带参

成员方法：

getXxx()/setXxx()

在给出一个show()方法，显示类的所有成员信息。

然后，写一个测试类，对学生的代码进行测试。
StudentDemo

7:删除项目和导入项目

删除项目

选中项目 – 右键 – 删除

从项目区域中删除

从硬盘上删除

导入项目
在项目区域右键找到import
找到General，展开，并找到
Existing Projects into Workspace
点击next,然后选择你要导入的项目
注意：这里选择的是项目名称

8:要注意的几个小问题

如何查看项目所在路径

选中 – 右键 – Properties – Resource – Location

导入项目要注意的问题

项目区域中不可能出现同名的项目(新建或者导入)

自己随意建立的文件夹是不能作为项目导入的

修改项目问题

不要随意修改项目名称

如果真要修改，不要忘记了配置文件.project中的

把这里改为你改后的名称

9:大家接收文件的注意事项

A:专门建立一个文件夹用于接收项目，不要随意放置。

B:同一个项目再次接收的时候，先去存放目录把原始项目删除，然后重新存储，最后刷新项目即可。

C:每天对照我写的项目，自己也创建一个练习项目

举例：我的项目名称 day11_eclipse

你就创建一个项目名称 day11_eclipse_test

10:Eclipse中代码的高级(Debug)调试

作用：

调试程序

查看程序执行流程

如何查看程序执行流程
要想看程序流程，就必须设置断点。

什么是断点：
就是一个标记，从哪里开始。

如何设置断点：
你想看哪里的程序，你就在那个有效程序的左边双击即可。

在哪里设置断点：
哪里不会点哪里。
目前：我们就在每个方法的第一条有效语句上都加。

如何运行设置断点后的程序：
右键 -- Debug as -- Java Application

看哪些地方：
Debug：断点测试的地方
在这个地方，记住F6，或者点击也可以。一次看一行的执行过程。
Variables：查看程序的变量变化
ForDemo：被查看的源文件
Console：控制台

如何去断点：
a:再次双击即可
b:找到Debug视图，Variables界面，找到Breakpoints，并点击，然后看到所有的断点，最后点击那个双叉。

八、eclipse中如何生成jar包并导入到新的项目中

1.jar包是什么？

（1）.jar是什么？

jar其实就是多个class文件的压缩包

（2）.jar有什么用？

用别人写好的东西

（3）.打jar包

选中项目–右键–Export–java–jar–自己制定

一个路径和一个名称–Finish

（4）.使用jar包

复制到项目路径下并添加至构建路径

**jar包和说明书一般是配套使用

2.如何制作帮助文档

eclipse中如何制作帮助文档：

（1）.编写源程序（设计接口，抽象类，具体类案例）

（2）.针对源程序添加文档注释

（3）.选中项目–右键–Export–java–javadoc–Finish

3.如何删除和导入项目

1.选中项目–右键–删除

从项目区域中删除（在硬盘上还能找到）

从硬盘上删除

2.导入项目

在项目区域右键找到import

找到General，展开，并找到

Exising Projects into Workspace

点击next，然后选择你要导入的项目

注意，这里选择的是项目名称

导入项目需要注意的问题：

项目区域中不可能出现同名的项目（新建或导入）

自己随意建立的文件夹是不能作为项目导入的

修改项目问题

不要随意修改项目名称

如果真要修改，不要忘记了配置文件.project中的

把这里改为你改后的名称

3.Debug调试

Eclipse中代码的高级Debug调试

作用：

调试程序

查看程序执行流程

如何查看程序执行流程

什么是断点

就是一个标记，从哪里开始

如何设置断点

你想看哪里的程序，就在有效程序的左边双击

在哪里设置断点

哪里不会点哪里。

目前：就在每个方法的第一条有效语句上都加

如何运行设置断点后的程序

右键–Debug as–java application

看那些地方

Debug:断点测试的地方

在这个地方，记住F6，或者点击也可以

variables:查看程序的变量变化

fordemo:被查看的源文件

console:控制台

如何去除断点

1.再次双击

2.找到debug视图，Variables界面，找到BreakPoingts,并点击，

然后看到所有的断点，最后点击那个双叉。

4.eclipse查看java中参数传递问题

/*
通过断点来看方法的参数传递以及进栈，出栈
*/

public class ArgsDemo{
public static void main(String[] args){
int a = 10;
int b = 20;
System.out.println("a:"+a+",b:"+b);
change(a,b);
System.out.println("a:"+a+",b:"+b);

int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]);
}

public static void change(int a,int b){
System.out.println("a:"+a+",b:"+b);
a = b;
b = a + b;
System.out.println("a:"+a+",b:"+b);
}

public static void change(int[] arr){
for(int x = 0; x < arr.length; x++){
if(arr[x] % 2 ==0){
arr[x] *= 2;
}
}
}
}