一.返回值
1.常量
2.引用
(1)具体类
返回该类的具体对象
代码示例
class Demo{
//成员方法
public float sum(float a,float b){
return (a + b) ;
}
}
//定义一个类
class Student{
public void show(){
System.out.println("好好学习,天天向上...");
}
}
//class StudentDemo{
// public void method(Student s){//形式参数是一个引用类型,那么需要该类对象Student s = new Student() ;
// s.show() ;
// }
//}
class StudentDemo{
public Student method(){//如果方法的返回值是一个具体的类,那么需要该类对象
/*Student s = new Student() ;
return s ;*/
return new Student() ;
}
}
//测试类
public class StudentTest {
public static void main(String[] args) {
//两个实际参数
/*int a = 10 ;
int b = 20 ;*/
float a = 10.0F;
float b = 12.34F;
//需求:需要调用sum来进行求和
Demo d = new Demo() ;
float result = d.sum(a, b) ;
System.out.println("result:"+result);
System.out.println("------------------------");
//需求:需要调用StudentDemo这个类中method()方法
//需要创建StudentDemo这个类的对象
// StudentDemo sd = new StudentDemo() ;
// //创建Student类的对象
// Student s = new Student() ;
//// sd.method(s) ;//当前s变量不可用
// sd.method(s) ;//s就代表Student类的对象,把空间地址值作为参数传递
//返回值是具体的类:
//创建StudentDemo类对象
StudentDemo sd = new StudentDemo() ;
Student s = sd.method() ;
s.show();
}
}
(2)抽象类
返回抽象类的子类对象(匿名类的方式)
代码示例
abstract class Person2{
public abstract void show() ;
}
//定义PersonDemo2类
class PersonDemo2{
public Person2 method(){ // 如果一个方法的返回值是一个抽象类,需要的返回是该抽象类的子类对象
/*Person2 p = new Teacher() ;
return p ;*/
return new Teacher() ;//Person2 p = new Teacher() ;
}
}
//抽象类的子类
class Teacher extends Person2{
@Override
public void show() {
System.out.println("老师爱高圆圆,爱生活...");
}
}
//测试类
public class PersonTest2 {
public static void main(String[] args) {
//需求:要调用PersonDemo2这个类中的method()方法
PersonDemo2 pd = new PersonDemo2() ;
Person2 p = pd.method() ;//pd.method();return new Teacher() ----->Person2 p = new Teacher() ;
p.show() ;
System.out.println("----------------");
//链式编程
Person2 p2 = new PersonDemo2().method() ;//链式编程
p2.show() ;
}
}
(3)接口
返回接口的子实现类(匿名内部类的方式)
代码示例
class TeacherDemo2{ //后面反射机制:--->javac TeacherDemo2.java----> TeacherDemo2.class(ClassLoder:类加载器)
//成员方法
public Love method(){ //如果一个方法的返回值是引用类型:接口类型 需要的是该接口对应的子实现类的对象
//由于返回值是是一个接口类型
// Love l = new Teacher2() ;//接口多态
// return l ;
return new Teacher2() ;
}
}
//定义接口的子实现类
class Teacher2 implements Love{
@Override
public void love() {
System.out.println("老师讲解javaSE......");
}
}
//测试类
public class TeacherTest2 {
public static void main(String[] args){
//需求:需要调用TeacherDemo2中的method()
TeacherDemo2 td = new TeacherDemo2() ;
//使用对象名调用功能
Love l = td.method() ;//Love l = new Teacher2(); 实质就是一个接口多态
l.love() ;
}
}
二.形式参数
1.常量
形参的改变不影响实际参数
2.引用
(1)具体类
需要该类的具体对象
代码示例
class Demo{
//成员方法
public float sum(float a,float b){
return (a + b) ;
}
}
//定义一个类
class Student{
public void show(){
System.out.println("好好学习,天天向上...");
}
}
//class StudentDemo{
// public void method(Student s){//形式参数是一个引用类型,那么需要该类对象Student s = new Student() ;
// s.show() ;
// }
//}
class StudentDemo{
public Student method(){//如果方法的返回值是一个具体的类,那么需要该类对象
/*Student s = new Student() ;
return s ;*/
return new Student() ;
}
}
//测试类
public class StudentTest {
public static void main(String[] args) {
//两个实际参数
/*int a = 10 ;
int b = 20 ;*/
float a = 10.0F;
float b = 12.34F;
//需求:需要调用sum来进行求和
Demo d = new Demo() ;
float result = d.sum(a, b) ;
System.out.println("result:"+result);
System.out.println("------------------------");
//需求:需要调用StudentDemo这个类中method()方法
//需要创建StudentDemo这个类的对象
// StudentDemo sd = new StudentDemo() ;
// //创建Student类的对象
// Student s = new Student() ;
//// sd.method(s) ;//当前s变量不可用
// sd.method(s) ;//s就代表Student类的对象,把空间地址值作为参数传递
//返回值是具体的类:
//创建StudentDemo类对象
StudentDemo sd = new StudentDemo() ;
Student s = sd.method() ;
s.show();
}
}
(2)抽象类
需要该类的子类
代码示例
abstract class Person{
public abstract void study() ;
}
//定义一个PersonDemo类
class PersonDemo{
//成员方法
public void method(Person p){//Person p = new Perosn();//错误的:抽象类不能实例化---->抽象类的多态:Person p = new Student2() ;
p.study() ;
}
}
//自定义一个抽象的子类来进行Person的实例化
class Student2 extends Person{
@Override
public void study() {
System.out.println("good good study ,day day up!");
}
}
//测试类
public class PersonTest {
public static void main(String[] args) {
//需求:调用PersonDemo类中method()方法
//创建PersonDemo类的对象
// PersonDemo pd = new PersonDemo() ;
//// pd.method(p) ;
// //需要使用抽象类多态来实例化
// Person p = new Student2() ;
// pd.method(p) ;
//链式编程:
new PersonDemo().method(new Student2()) ;
}
}
(3)接口
需要该类的子实现类
代码示例
//定义一个接口
interface Inter{
public abstract void love() ;
}
//定义一个类
class TeacherDemo{
public void method(Inter i){//接口不能实例化: 如果一个方法的形式参数是一个接口,那么需要创建该接口的子实现类对象
i.love() ;
}
}
//由于接口不能实例化,需要定义接口的子实现类
class Student3 implements Inter{
@Override
public void love() {
System.out.println("学生爱学习,爱java...");
}
}
//测试类
public class TeacherTest {
public static void main(String[] args) {
//需求:需要调用TeacherDemo类中的method()方法
//创建该类对象
TeacherDemo td = new TeacherDemo() ;
//创建该接口对象:通过接口多态
Inter i = new Student3() ; //接口多态
/* Inter i = new Inter() { //匿名内部类
@Override
public void love() {
System.out.println("学生爱学习,爱java...");
}
};*/
td.method(i) ;
System.out.println("----------------");
//匿名内部类:
Inter i2 = new Inter() {
@Override
public void love() {
System.out.println("学生爱学习,爱java...");
}
};
i2.love();
}
}
三.内部类
内部类:特点 可以直接访问外部类的成员,包括私有
1.成员内部类
在一个类的成员位置定义一个类
成员内部类访问它自己类中的成员方法:
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
静态的成员内部类要访问它自己的类中的成员方法
静态的成员内部类要访问外部类的成员,该成员需要静态修饰
外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
class Outer4{
//外部类的两个成员变量
public static int num = 10 ;
public static int num2 = 20 ;
/**
* 结论:
* 对于静态的成员内部类来说,无论静态成员内部类中的成员方法是静态还是非静态的,要访问外部类的成员变量,该变量必须被static修饰
* */
//定义一个静态的成员内部类
public static class Inner4{
//非静态的内部类的成员方法
public void show(){
System.out.println(num);
System.out.println(num2);
}
//静态的内部类的成员方法
public static void show2(){
System.out.println(num);
System.out.println(num2);
}
}
}
//测试类
public class InnerDemo4 {
public static void main(String[] args) {
//需求:要访问静态成员内部类Inner4里面的show(),show2()方法
//外部类名.内部类 对象名 =外部类对象.内部类对象;
// Outer4.Inner4 oi = new Outer4().new Inner4() ;
// oi.show() ;
//静态的成员内部类访问该类中的成员方法:
//格式:外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
Outer4.Inner4 oi = new Outer4.Inner4() ;
oi.show() ;
oi.show2() ;//静态方法
System.out.println("--------------");
//show2()还有另外一种访问方式:
Outer4.Inner4.show2() ;
}
}
2.局部内部类
在一个类的局部位置定义一个类
局部内部类的成员变量应该被finial修饰(如果修饰jdk1.70会报错 jdk1.80不会—已经封装好了)
//外部类
class Outer5{
//外部类的成员变量
// public int num = 100 ;
private int num = 100 ;
//外部类的成员方法
public void method(){
//局部变量
final int num2 = 200 ; //自定义常量(细节问题)
//局部位置
class Inner5{
//局部内部类的成员方法
public void show(){
System.out.println(num);
//局部内部类中访问局部变量
System.out.println(num2); //jdk1.7才会有这个错误! jdk1.8---->封装好了,所以不会出现错误!
}
}
Inner5 i = new Inner5() ;
i.show() ;
}
}
//测试类
public class InnerDemo5 {
public static void main(String[] args) {
//对于局部内部类访问具该类的成员方法:创建外部类对象 使用外部类对象调用外部类的成员方法
Outer5 o = new Outer5() ;
o.method();
}
}
3.匿名内部类
* 是内部类的简化版格式
* 前提条件:
* 必须存在一个接口或者是一个类(可以是具体类,也可以是一个抽象类)
*
* 书写的格式:
* new 接口名或者类名(){
* 方法重写;
* }
*
*
* 匿名内部类的实质:
* 继承了该类(抽象类)或者是实现了该接口的子类对象!
* */
//定义一个接口
interface Inter{
//抽象功能
public abstract void show() ;
public abstract void show2() ;
}
//外部类
class Outer6{
//成员方法
public void method(){
//当接口中有一个方法的时候
// new Inter(){
//
// @Override
// public void show() {
// System.out.println("show");
// }
//
// }.show() ;
//当接口中有两个方法的时候
/*new Inter(){
@Override
public void show() {
System.out.println("show");
}
@Override
public void show2() {
System.out.println("show2");
}
}.show() ;
new Inter(){
@Override
public void show() {
System.out.println("show");
}
@Override
public void show2() {
System.out.println("show2");
}
}.show2();*/
//使用接口名 对象名 = 匿名内部类的格式: new 接口名(){
//方法重写();
//}
// Inter i2 = new Inter() ;
Inter i = new Inter(){
@Override
public void show() {
System.out.println("show");
}
@Override
public void show2() {
System.out.println("show2");
}
};
//使用对象名调用
i.show();
i.show2() ;
}
}
//测试类
public class InnerDemo6 {
public static void main(String[] args) {
Outer6 o = new Outer6() ;
o.method() ;
}
}