JAVASE-09：参数传递、内部类的理解与常用类的学习

1. 参数传递

形式参数的传递：
a.当以后看到一个方法的形参 需要一个类类型，你就传递一个该类的对象（没有可以定义一个）。

package org.westos.demotest;

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        set(student,20);

        student.show(new Student(),80);
    }
    public static void set(Student student,int num){
    }
}
class Student{
    public void show(Student student,int num){}
}

b.当以后看到一个方法的形参 需要一个抽象类类型，你就传递一个该类的子类对象（没有可以定义一个）。

package org.westos.demotest;

public class MyTestTwo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        set(cat,80);
        cat.show();
    }
    public static void set(Animal an,int num){}
}

abstract class Animal{
    public abstract void show();
}
class Cat extends Animal{
    @Override
    public void show() {
    }
}

c.当以后看到一个方法的形参 需要一个接口类型，你就传递一个该接口的子类对象（没有可以定义一个）。

package org.westos.demotest;

public class MyTestThree {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        set(myClass,70);
        myClass.show();
    }
    public static void set(MyInterface myInterface,int num){}
}

interface MyInterface{
    void show();
}
class MyClass implements MyInterface{
    @Override
    public void show() {

    }
}

返回值类型的传递：

a.当以后看到一个方法的返回值类型 需要一个类类型，你就返回一个该类的对象（没有可以定义一个）。

package org.westos.demotest;

public class MyTestA {
    public static void main(String[] args) {
        Teacher teacher=getTeacher();
        teacher.getTea();
    }
    public static Teacher getTeacher(){
        Teacher teacher=new Teacher();
        return teacher;
    }
}

class Teacher{
    public Teacher getTea(){return this;}
}

b.当以后看到一个方法的返回值类型 需要一个抽象类类型，你就传递一个该类的子类对象（没有可以定义一个）。

package org.westos.demotest;

public class MyClassB {
    public static void main(String[] args) {
        AnimalDog ad=getAnimal();
        Dog dog=(Dog) ad;
    }
    public static AnimalDog getAnimal(){
        Dog dog = new Dog();
        return dog;
    }
}

abstract class AnimalDog{}
class Dog extends AnimalDog{}

c.当以后看到一个方法的返回值类型 需要一个接口类型，你就传递一个该接口的子类对象（没有可以定义一个）。

package org.westos.demotest;

public class MyTestC {
    public static void main(String[] args) {
        Myinterface myinterface = getMyinterface();
    }
    public static Myinterface getMyinterface(){
        return new gouzi();
    }
}

interface Myinterface{}
class gouzi implements Myinterface{}

它返回什么类型，就用什么类型来收：

---

2.链式编程的语法风格

当你调用完一个方法后，他返回一个对象，那你就可以紧接着打点 . 再去调用这个对象所属类中的方法… …

package—包，就是文件夹，用来解决同一个路径下不能存在同名文件的问题(分类管理)；不同包下的类之间进行访问 要用import进行导包。

定义包的格式： package 包名;（多级包用.分开即可）

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

package org.westos.demotest;
import org.westos.demotest.MyTest;

public class MyTestLSBC {
    public static void main(String[] args) {
        int age=getPer().getPerson().show(100).getAge();
        System.out.println(age); // 20
    }
    public static Person getPer(){
        return new Person();
    }
}
class Person{
    int age=20;
    public int getAge(){return age;}
    public Person getPerson(){
        Person person = new Person();
        return person;
    }
    public Person show(int age){
        return this;
    }
}

---

3.权限修饰符

四种权限修饰符: private(私有的) , 默认 , protected(受保护的) , public(公共的)

本类	同一个包下(子类和无关类)	不同包下(子类)	不同包下(无关类)
private	Y
默认	Y	Y
protected	Y	Y	Y
public	Y	Y	Y

A:修饰符：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract

B:修饰类的关键字：
权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract
用的最多的就是：public

C:修饰成员变量的关键字：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
用的最多的就是：private

D:修饰构造方法的关键字：
权限修饰符：private，默认的，protected，public
用的最多的就是：public

E:修饰成员方法的关键字：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
用的最多的就是：public

F:除此以外的组合规则：
成员变量：public static final
成员方法：public static / abstract / final

---

4.内部类

将类A定义到类B中，那么类A 就称之为内部类，类B可以称之为外部类。

根据内部类位置不同，分为成员内部类和局部内部类：

成员内部类–把内部类定义到外部类的成员位置（类中方法外）

局部内部类–把内部类定义到外部类的局部位置（方法内）

在测试类中直接访问内部类的成员：外部类名.内部类名 对象名 = 外部类对象.内部类对象;

4.1 成员内部类：

创建内部类对象–Outer.Inner inner=new Outer().new Inner();

特点：
a.内部类可以直接访问外部类的成员，包括私有成员；
b.外部类不能直接访问内部类的成员，要访问就必须创建内部类的对象；
c.private—内部类可以使用private来修饰，可以用来隐藏细节，私有的内部类，外界无法创建对象；

package org.westos.demo2;

public class MyTest2 {
    public static void main(String[] args) {
        //私有的内部类，外界无法创建其对象。
        //Wai.Nei nei=new Wai().new Nei();
        Wai wai = new Wai();
        wai.test();
    }
}

class Wai {
    //内部类，可以使用private来修饰
    private class Nei {
        public void neiShow() {
            System.out.println("内部类的方法");
        }
    }
    public void test(){ //在外部类方法中，创建内部类对象，调用其中的方法
        Nei nei = new Nei();
        nei.neiShow();
    }
}

d.static—内部类可以使用static来修饰，可以用来隐藏细节，静态的内部类，外界创建静态内部类的语法简化了；静态内部类只能访问外部类的静态成员。

package org.westos.demo3;

public class MyTest {
    public static void main(String[] args) {
        //创建静态内部类的语法
        Outer.Inner inner=new Outer.Inner();
        //静态内部类，只能访问外部类的静态成员，不能访问非静态成员。
        inner.neiShow();
    }
}

class Outer {
    static int num=20;
    //内部类，可以使用static来修饰
    static class Inner {
        public void neiShow(){
            System.out.println(num);
            hehe();
        }
    }
    public static void hehe(){
    }
}

注意语法：调用外部类中的 Outer.this.num

this代表的是内部类的对象，

Outer.this 代表外部类的对象。

填空，要求：使用已知的变量，在控制台输出30，20，10
	class Outer {
		public int num = 10;
		class Inner {
			public int num = 20;
			public void show() {
				int num = 30;
				System.out.println(num);  //30 就近原则
				System.out.println(this.num); //20 
				System.out.println(new Outer().num); //10
			}
		}
	}
	
	class InnerClassTest {
		public static void main(String[] args) {
			Outer.Inner oi = new Outer().new Inner();
			oi.show();
		}	
	}

4.2 局部内部类：

a.内部类都可以直接访问外部类的成员，包括私有成员；

b.局部内部类外界没有其创建对象的语法；

package org.westos.demo5;

public class MyTest {
    public static void main(String[] args) {
        //1.内部类都能直接访问外部类的成员，包括私有成员。
        //2.成员内部类，外界没有其创建对象的语法。
        Wai wai = new Wai();
        wai.show();
    }
}

class Wai {
    int num = 20;
    private int age = 30;

    class Inner {
    }

    public void show() {
        //局部内部类
        class Nei {
            int b = 1;
            public void neiTest() {
                System.out.println(num);
                System.out.println(age);
                test();//调用外部类的私有方法
            }
            public void neiShow() {
                System.out.println("nei show");
            }
        }
        Nei nei = new Nei();
        nei.neiTest();
        nei.neiShow();
    }
    private void test() {
        System.out.println("外部类的私有方法");
    }
    public void hehe() {
        //Nei nei=new Nei();
        //Inner inner = new Inner();
        show();
    }
}

c.局部内部类访问外部类的局部变量 外部类的局部变量，必须为一个常量。

package org.westos.demotest;

public class MyTestNBL {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.waiShow(300);
    }
}
class Outer{
    int b=1000;
    public void waiShow(int num){
        int a=200;
        class Inner{
            public void neiShow(){
                System.out.println(b);
                System.out.println(a);
                System.out.println(num);
            }
        }
        Inner inner = new Inner();
        inner.neiShow();
    }
}

4.3 匿名内部类：

它是局部内部类的一种简写形式

语法格式：new 接口名/类名(){重写方法}

package org.westos.demotest;

public class NMNBL {
    public static void main(String[] args) {
        new monkey(){
            @Override
            public void show() {
                System.out.println("重写了父类的抽象方法");
            }
        }.show();
    }
}
abstract class monkey{
    public abstract void show();
}
class M extends monkey{
    @Override
    public void show() {
    }
}

本质：匿名内部类本质上是一个对象，是谁的对象，是 实现了该接口 或者 继承了 该抽象类 的子类对象。经常用用于传参，对于一个普通的类，我们也可以使用匿名内部类，来创建该类的子类对象。

package org.westos.demo2;

public class MyTest {
    public static void main(String[] args) {
        //使用同一个匿名内部类，来调用两个方法。
        //多态
        MyInterface myInterface = new MyInterface() {
            @Override
            public void aa() {
                System.out.println("aaaaaaaaaaaaaaa");
            }
            @Override
            public void bb() {
                System.out.println("bbbbbbbbb");
            }
        };
        myInterface.aa();
        myInterface.bb();
    }
}

interface MyInterface {
    void aa();
    void bb();
}

在一个类里面，也可以定义一个接口，在外界可以采用匿名内部类的方式，内部接口的子类对象；内部接口也可以私有，私有后外界无法创建其子类对象。

package org.westos.demotest;

public class NMNBL {
    public static void main(String[] args) {
    public static YourInterface getYI(){
        return new YourInterface() {
            @Override
            public void show() {

            }
        };
    }
    public static monkey HZ(){
        return new monkey() {
            @Override
            public void show() {

            }
        };
    }
}
    
abstract class monkey{
    public abstract void show();
}
class M extends monkey{
    @Override
    public void show() {
    }
}
interface YourInterface{
    void show();
}

练习：

package org.westos.demo6;

interface Inter {
    void show();
}
//类
class Outer {
   //补齐代码 要求在控制台输出”HelloWorld”
   public static Inter method(){
      return new Inter() {
         @Override
         public void show() {
            System.out.println("hello world");
         }
      };
   }
}

//测试类
class OuterDemo {
    public static void main(String[] args) {
        Outer.method().show();
    }
}

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

5. 常用类的学习

API(Application Programming Interface) ：应用程序编程接口。
Java API：就是Java提供给我们使用的类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

Object：所有类的顶层父类 所有的类都是直接或者间接继承自他。

hashCode()：返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。不同对象的哈希码值是不一样的（不是对象的实际地址值，可以理解为逻辑地址值）。

public class MyTest extends Object {
    public static void main(String[] args) {
        Object obj = new Object();
        int code = obj.hashCode();
        System.out.println(code);// 356573597

        Object obj2 = new Object();
        int code2 = obj2.hashCode();
        System.out.println(code2);// 1735600054
    }
}

getClass()：获取该类的字节码文件对象，当Object.class这个字节码文件加载的时候，JVM就会为字节码文件来创建对象，这个字节码文件对象，用Class类型来描述。

package org.westos.demo;

public class MyTest2 {
    public static void main(String[] args) {
        //getClass() 获取该类的字节码文件对象
        Object obj1 = new Object();
        Object obj2 = new Object();
        System.out.println(obj1);// java.lang.Object@1540e19d
        System.out.println(obj2);// java.lang.Object@677327b6
        System.out.println(obj1 == obj2);// false
        //获取 Object.class 这个字节码文件对象
        Class<?> aClass1 = obj1.getClass();
        System.out.println(aClass1.getName());// java.lang.Object
        Class<?> aClass2 = obj2.getClass();
        System.out.println(aClass1 == aClass2);// true
    }
}

toString()：获取该对象的地址值，以字符串形式返回。

Object类中的toString()方法的默认实现，是在获取对象的地址值，但是我们任务老是看对象的地址值意义不大。
当子类调用toString()方法时，打印成员变量的值来说更有意义。

当你以后输出一个对象名，输出的不是地址值，就说明该类重写了父类Object中的toString()。

package org.westos.demo3;

import java.util.Scanner;

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.setAge(23);
        // System.out.println(student.getName()+"=="+student.getAge());
        // student.show();
        System.out.println(student);

        Scanner scanner = new Scanner(System.in);
        //当你以后输出一个对象名，输出的不是地址值，就说明该类重写了父类Object中的toString();
        System.out.println(scanner.toString());
    }
}


class Student {
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void show() {
        System.out.println(this.name + "==" + age);
    }

    //IDEA 可以按 alt+insert 自动重写toString()方法
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}