Problems with formal parameters and return values:
1: Problem of formal parameters and return values (understanding) (1) Formal parameters: class Name: Object abstract class name required for this class : Subclass object Interface name that requires this class : An implementation class object that requires the interface (2 return value type: class Name: Returns the object abstract class name of the class: Returns the Subclass object interface name of the class: an object (3) Chained programming object that returns the implementation class of the interface . Method 1 ( ). Method 2 () .... Method N (); This usage: In fact, after the invocation of Method 1 (), an object should be used, and after the call of Method 2 (), an object should be returned. after the method N () call is complete, the object may or might not be an object.
Class masterpieces as formal parameters
/*formal Parameters: Basic types (too simple, not what I'm going to talk about today) reference type class name: (as we've already said about anonymous objects), we need an abstract class of objects of this class: Interface*/classStudent { Public voidStudy () {SYSTEM.OUT.PRINTLN ("Good good study,day day up"); }}classStudentdemo { Public voidMethodStudent S) {//SS; ss = new Student (); The object of the class is required S.study (); }}classStudenttest { Public Static voidMain (string[] args) {//requirements: I want to test the study () method of the student classStudent s =NewStudent (); S.study (); System.out.println ("----------------"); //Requirement 2: I want to test method () methods in the Studentdemo classStudentdemo SD =NewStudentdemo (); Student SS = new Student (); Sd.method (SS); System.out.println ("----------------"); //Anonymous Object Usage NewStudentdemo (). Method (NewStudent ()); }}
Abstract class masterpieces as formal parameters
/*formal Parameters: Basic types (too simple, not what I'm going to talk about today) reference type class name: (as we've already said about anonymous objects), we need an abstract class of objects of this class : the abstract Sub-class object interface*/Abstract classPerson { Public Abstract voidstudy ();}classPersondemo { Public voidMethod (person p) {//p; p = new Student (); Person p = new Student (); polymorphicP.study (); }}//define a specific class of studentsclassStudentextendsPerson { Public voidStudy () {SYSTEM.OUT.PRINTLN ("Good good study,day day up"); }}classPersontest { Public Static voidMain (string[] args) {//There's no way to use it at the moment .//because the abstract class has no corresponding concrete class//So, we should first define a specific class//requirement: I want to use method () in the Persondemo classPersondemo PD =NewPersondemo (); Person P = new Student (); Pd.method (p); }}
Interface name as formal parameter
/*formal Parameters: Basic types (too simple, not what I'm going to talk about today) reference type class name: (as we've already said about anonymous objects) What you need is an abstract class of objects of that class: This abstract subclass object is required Interface: The implementation class object for the interface is required *///define a hobby's interfaceInterfaceLove { Public Abstract voidLove ();}classLovedemo { Public voidMethodLove L) {//l; L = new Teacher (); Love L = new Teacher (); polymorphicL.love (); }}//Define concrete classes to implement interfacesclassTeacherImplementsLove { Public voidLove () {System.out.println ("Teachers love students, Love Java, love Brigitte"); }}classTeachertest { Public Static voidMain (string[] args) {//requirement: I want to test the Love () method in the Lovedemo classLovedemo ld =NewLovedemo (); Love l = new Teacher (); Ld.method (l); }}
class masterpieces are return value class type
/*return value type base type: (Basic type too simple, I'm not going to explain) reference type: class: Returns the object abstract class for this class : interface: */classStudent { Public voidStudy () {SYSTEM.OUT.PRINTLN ("Good good study,day day up"); }}classStudentdemo { Public Student getstudent () {//Student s = new Student (); //Student ss = S; //Student s = new Student (); //return s; return new Student (); }}classStudentTest2 { Public Static voidMain (string[] args) {//requirement: I want to use the study () method in the Student class//However, this time my request is not to directly create student objects//Let you use Studentdemo to help you create objectsStudentdemo SD =NewStudentdemo (); Student s= Sd.getstudent ();//new Student (); Student s = new Student ();S.study (); }}
Abstract class as return value type
/*return value type base type: (Basic type too simple, I'm not going to explain) reference type: Class: Returns the object abstract class for this class : The subclass object of the abstract class is returned Interface:*/Abstract classPerson { Public Abstract voidstudy ();}classPersondemo { PublicPerson Getperson () {//Person p = new Student (); //return p; return new Student (); }}classStudentextendsPerson { Public voidStudy () {SYSTEM.OUT.PRINTLN ("Good good study,day day up"); }}classPersonTest2 { Public Static voidMain (string[] args) {//requirement: I want to test the study () method in the person classPersondemo PD =NewPersondemo (); Person P= Pd.getperson ();//new Student (); Person p = new Student (); polymorphicP.study (); }}
Interface as the return value type
/*return value type base type: (Basic type too simple, I'm not going to explain) reference type: Class: Returns the object abstract class for this class: The subclass object of the abstract class is returned Interface: An object that returns an implementation class for the interface *///define a hobby's interfaceInterfaceLove { Public Abstract voidLove ();}classLovedemo { PublicLove Getlove () {//Love L = new Teacher (); //return l; return NewTeacher (); }}//defining a concrete class implementation interfaceclassTeacherImplementsLove { Public voidLove () {System.out.println ("Teachers love students, Love Java, love Brigitte"); }}classTeacherTest2 { Public Static voidMain (string[] args) {//How to test it?Lovedemo ld =NewLovedemo (); Love L= Ld.getlove ();//new Teacher (); Love L = new Teacher (); polymorphicL.love (); }}
Chained programming
/* chain-type programming. Each time the method is called, an object is returned. */classStudent { Public voidStudy () {SYSTEM.OUT.PRINTLN ("Good good study,day day up"); }}classStudentdemo { PublicStudent getstudent () {return NewStudent (); }}classStudentTest3 { Public Static voidMain (string[] args) {//How is it called ?Studentdemo SD =NewStudentdemo (); //Student s = sd.getstudent (); //S.study (); //attention, this is a chain-based programming sd.getstudent (). Study (); }}
10-02 the problem of Java form parameters and return values in-depth study, chained programming