java学习day07---形参实参&抽象类&内部类

一.形式参数问题

当形式参数为基本数据类型的时候,直接传参即可

当数据类型为引用数据类型时,当分情况讨论

1.具体类型

需要该具体类的对象

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

//定义StudentMethod类
class StudentMethod{
	public void method(Student s) {  //Student s = new Student() ;
		s.study();
	}
}

//测试类
public class StudentTest {
	
	public static void main(String[] args) {
		
		//需求:需要调用StudentMethod类中method方法
		//创建StudentMethod这个类的对象,对象调用method方法
		/**
		 * 方法的形式参数如果是一个引用类型,并且引用是一个具体类,需要传递的是该类型具体对象
		 */
		//创建StudentMethod类对象
		StudentMethod sm = new StudentMethod() ;
		//创建Student类的具体对象
		Student s  = new Student() ;
		sm.method(s);
	}
}

2.抽象类

需要手动给出该抽象类的具体子类,通过抽象类多态的方式创建对象

package westos.org.args_and_return;
//自定一个person类,Pereson类是一个抽象类
abstract class Person{
	//抽象方法
	public abstract void stduy() ;
}

//自定义一个PersonMethod类
class PersonMethod{
	//成员方法
	public void method(Person p) { //形式参数的类型是一个抽象类型		Person p = new Student2() ;
		p.stduy();
	}
}

//使用最传统方式:形式参数如果是一抽象类,手动给出抽象类的子类(具体类)
class Student2 extends Person{

	@Override
	public void stduy() {
		System.out.println("好好学习,天天向上.");
	}
	
}

//测试类
public class PersonTest {
	
	public static void main(String[] args) {
		
		//需求:调用PersonMethod类中method方法
		//创建PeresonMethod类 对象
		PersonMethod pm = new PersonMethod() ;
		//创建Person类对象
//		Person p = new Person() ;
		//创建子类对象,通过抽象类多态的形式
		Person p = new Student2() ;
		pm.method(p);
	}
}

注意:在开发中常用:匿名内部类的方式

3.接口

需要手动给出子类实现该接口,并用多态方式创建对象

//给出测试类
public class Test {
	public static void main(String[] args) {
        //先用多态的方式创建对象
		F f = new S();
        //将创建的对象作为参数传入,执行构造方法
		Stu stu = new Stu(f);
	}
}

//接口
interface F {
	public abstract void show();
}

//实现接口的子类
class S implements F {
	public void show() {
		System.out.println("------------");
	}	
}

class Stu {
	public Stu(F f) {  //参数为接口
		f.show();
	}
}

二.返回值

返回值为基本数据类型时,直接传递即可

当为引用类型时,需要分情况讨论

1.具体类
需要在方法中创建该类的具体对象

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

class StudentMethod3{
	public Student3 method() {		
		//如果返回值是一个引用类型,就需该引用类型具体对象
		Student3 s = new Student3() ; //方式1:传统创建对象的方式
		
		return s ;
		
		//return new Student3() ;  //方式2:匿名对象的方式
	}
}

//测试类
public class StudentTest2 {

	public static void main(String[] args) {
		//需要调用StudentMethod3类中的method方法
		StudentMethod3 sm = new StudentMethod3() ;
		Student3 s = sm.method() ;
		s.study();		
	}
}

2.接口

需要先创建一个子类实现该接口,然后在方法中利用多态的方式创建具体对象

interface Inter{
	void study() ;
}

class MethodDemo{
	//返回值:接口
	public Inter getMethod() { //返回值是一个接口类型,需要该接口的子实现类对象
		Inter inter = new InterImpl() ;
		return inter ;
	}
}

//定义子实现类
class InterImpl implements Inter{
	public void study() {
			System.out.println("爱学习,爱生活...");
	}
	
}

//测试类
public class TeacherTest2 {

	public static void main(String[] args) {
		//需要调用MethodDemo中的getMethod()方法
		MethodDemo md = new MethodDemo() ;		
		//调用方法
		Inter i = md.getMethod();
		i.study();
	}
}

3.抽象类

需要创建一个具体子类继承该抽象类,然后在方法中利用多态的方式创建对象

具体代码和接口类似,不再赘述

三.内部类

在类A中定义一个类B,则类B称为内部类,内部类可以访问外部类的成员,包括私有的

如果外部类想要访问内部类成员,则需要创建内部类对象,让内部类自己去访问

1.成员内部类

定义在一个类成员位置的类

外部类访问内部类的方式:外部类名.内部类名  对象名 = 外部对象.内部对象;

class Outer1{
	//外部类的成员变量
	private int num = 100;
	//成员内部类
	class Inner1{
		public void show() {
			System.out.println(num);
			System.out.println("show Inner1...");
		}
	}
}

public class Test1 {
	public static void main(String[] args) {
		Outer1.Inner3 oi = new Outer1().new Inner1();
		oi.show();
	}
}

2.静态内部类

成员内部类用修饰符static修饰,有利于方便访问

对于静态的成员内部类:外部类要访问当前该内部类的成员方法的格式:
 外部类名.内部类名 对象名 = new 外部类名.内部类名() ;

class Outer4{
	//外部类的成员变量
	public int num = 10 ;
	public static int num2 = 20 ;
	
	//定义一个静态的成员内部类
	public static class Inner4{   //将静态的成员内部类看成是外部类的一个成员..
		//定义成员方法
		public void show() {
			System.out.println(num2);
		}
		
		//静态的成员方法
		public static void show2() {
			System.out.println(num2);
		}
	}
}

//测试类
public class OuterDemo4 {
	public static void main(String[] args) {
		Outer4.Inner4 oi = new Outer4.Inner4() ;
		oi.show();
		oi.show2();
		
		//show2()还有另外一种访问方式
		//把静态成员内部类当做外部类的成员
		Outer4.Inner4.show2();
	}
}

注意:静态内部类只能访问外部类的静态成员

3.局部内部类

定义在一个类方法中的类

在访问时,要先在外部类中创建一个内部类对象

class Outer5{
	//私有的成员变量
	private int num = 100 ;	
	//外部类的成员方法
	public void method() {
		//局部变量 
		int num2 = 50 ;		
		//局部内部类Inner5
		class Inner5{
			//局部内部类的成员方法
			public void show() {
				System.out.println(num);
				System.out.println(num2); 
			}
		}
		
		//创建对象去访问:在外部类的成员方法中创建内部类对象,对象名.局部内部类的成员方法
		Inner5 inner = new Inner5() ;
		inner.show();
	}
	
}
//测试
public class OuterDemo5 {
	
	public static void main(String[] args) {
		Outer5 o = new Outer5() ;
		o.method();
	}
}

值得注意的是:在1.7版本及以下,局部内部类如果想要访问外部类的局部变量,则该变量前必须要加上final

原因:在外部类中创建一个内部类对象,该对象创建完毕,不会立即被gc回收掉,而局部变量是随着方法的调用结束而立即释放的,因此想要调用就要保证该变量有持久性,因此要加final让其变为常量才可以

4.匿名内部类

顾名思义:没有名字的内部类,在外部类中不需要class一个内部类,而是new,前提必须要有一个接口或类

格式: new 类名/接口名(){
               重写/实现一些方法()..
            } ;

interface Inner6{
	public abstract void show1() ;
	public abstract void show2() ;
}

//外部类
class Outer6{
	//有一个成员方法
	public void method() {
		//当接口中只有一个方法的时候的调用
		/*new Inner6() {

			@Override
			public void show1() {
				System.out.println("show1 Inner6...");
			}
			
		}.show1();*/
		
		//当接口中有多个方法调用的时候,写法非常麻烦,所以需要改进
		//接口中,接口的内部类的方式
			public void show1() {
				System.out.println("show1 Inner6...");
			}
			public void show2() {
				System.out.println("show2 Inner6...");
			}		
		};
		i.show1();
		i.show2();
	}
}

//测试类
public class OuterDemo6 {
	public static void main(String[] args) {
		Outer6 o = new Outer6() ;
		o.method();
	}
}

四.toString方法

属于根类Object中的方法

调用该方法时输出的是地址值,一般情况都要求重写toString方法

alt+shift+s --> 可以在列表中选择自动重写toString方法

 

你可能感兴趣的:(java学习day07---形参实参&抽象类&内部类)