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方法