JAVA中的包，修饰符及匿名内部类

一、形参和返回值问题

1、形式参数：
（1）类做实际参数：需要的是该类的对象

class Student {
    public void study(){
        System.out.println("学生要学Java");
    }
}
class StudentUse{
    //类做形式参数
    public void show(Student s) {
        s.study();
    }
}
public class StudentDemo {
    public static void main(String[] args) {
        Student s = new Student();
        StudentUse ss = new StudentUse();
        ss.show(s);
    }
}

（2）抽象类做实际参数：需要该抽象类的子类对象

abstract class Person{
    public abstract void study() ;
}
class PersonDemo{
    //抽象类做形参
    public void show(Person s) {
        s.study();
    }
}
class Student extends Person{
    public void study() {
        System.out.println("学Java还阔以");
    }
}
public class StudentDemo2 {
    public static void main(String[] args) {
        Student s = new Student();
        PersonDemo pd = new PersonDemo();
        //通过子类访问父类 
        pd.show(s);
    }
}

（3）接口做实际参数：需要的是该接口的实现类对象

interface Hobby{
    public abstract void eat();
}
class HobbyDemo{
    public void show(Hobby h) {
        h.eat();
    }
}
class Student implements Hobby{
    public void eat() {
        System.out.println("我爱吃火锅");
    }
}
public class StudentDemo2 {
    public static void main(String[] args) {
        HobbyDemo hd = new HobbyDemo();
        Student s = new Student();
        hd.show(s);
        
    }
}

2、返回值：
（1)返回值为一个类：返回的是该类的对象

class Student1{
    public void study() {
        System.out.println("学Java还阔以");
    }
}
class Student1Demo{
    //返回值为一个类
    public Student1 getStudent() {
        return new Student1();
    }
}
public class StudentDemo2 {
    public static void main(String[] args) {
        Student1Demo sd = new Student1Demo();
        Student1 s= sd.getStudent();
        s.study();
    }
}

(2)抽象类：返回的是该抽象类的子类对象

abstract class Person{
    public abstract void study();
}
class PersonDemo{
    public Person getPerson() {
        return new Student1();
    }
}
class Student1 extends Person{
    public void study() {
        System.out.println("学Java还阔以");
    }
}
public class StudentDemo2 {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo();
        Person p = pd.getPerson();
        p.study();
    }
}

（3）接口：

interface Hobby{
    public abstract void eat();
}
class HobbyDemo{
    public Hobby show() {
        return new Student();
    }
}
class Student implements Hobby{
    public void eat() {
        System.out.println("我爱吃火锅");
    }
}
public class StudentDemo2 {
    public static void main(String[] args) {
        HobbyDemo hd = new HobbyDemo();
        Hobby h = hd.show();
        h.eat();
    }
}

3、链式编程：

对象.方法1().方法2()....方法n();

方法1-n-1返回的是一个对象，方法n返回的可以是对象也可以不是对象

二、包：对类进行分类管理

1、包的定义：
           package 包名；
     多级包用.分开
2、注意事项：
    package语句必须是程序的第一条可执行代码
    如果没有package，默认表示无包名

三、导包：不同包下的类之间的访问

格式：import 包名...类名；

 

四、权限修饰符

1、public：可以在任何地方被访问
2、protected：子类可以访问
3、默认：同一个包下可以访问
4、private：只能在本类中被访问

五、常见的修饰符

1、分类：

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

2、类：
权限修饰符：默认  public
状态修饰符：final
抽象修饰符：abstract
用的最多的是：public

3、成员变量：
权限修饰符：private  默认  protected  public
状态修饰符：static  final
用的最多的是：private

4、构造方法：
权限修饰符：private  默认  protected  public
用的最多的是：public

5、成员方法：
权限修饰符：private  默认  protected  public
状态修饰符：static  final
抽象修饰符：abstract
用的最多的是：public

六、内部类：定义在其他类的内部的类

1、访问特点：

内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的额成员，必须先创建对象

2、分类：

（1）成员内部类：在成员位置定义的类

  格式：外部类名.内部类名 对象名 = 外部对象名.内部对象名

  A：成员内部类的修饰符：
  private修饰内部类：为了保证数据的安全性
  通过外部类的方法进行访问
  B：static修饰内部类：为了方便访问数据
  静态内部类只能访问用静态修饰的外部类成员
  外部类.内部类.方法名（）;

（2）局部内部类：在方法中定义的类

  可以直接访问外部类的成员
  在局部位置，可以创建对象，通过对象调用内部类方法，来实现局部内部类功能
  注意：局部内部类使用局部变量，需要局部变量是final修饰的

成员内部类：

class Outer{
	private int num = 10;
	class Inner{
		public void show() {
			System.out.println(num);
		}
	}
}
public class InnerDemo {
	public static void main(String[] args) {
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
} 

3、匿名内部类：就是内部类的简化写法

（1）前提：存在一个类（具体类或者是抽象类）或者接口

（2）格式：new 类名或者接口名（）{
                                 重写方法；
                 }

（3）本质：是一个继承了该类或者实现了该接口的子类的匿名对象

abstract class Inner{
	public abstract void show();
	public abstract void show2();
}
class Outer{
	public void method() {
		//匿名内部类
		Inner i = new Inner(){//多态
			public void show() {
				System.out.println("show");
			}
			public void show2() {
				System.out.println("show2");
			}
		};
		i.show();
		i.show2();
	}
}
public class InnerDemo {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

 

（4)匿名内部类的使用：

interface Person {
	public abstract void study();
}
class PersonDemo{
	public void getStudy(Person p) {
		p.study();
	}
}
public class InnerDemo {
	public static void main(String[] args) {
		PersonDemo pd = new PersonDemo();
		pd.getStudy(new Person() {//匿名内部类，只能使用一次
			public void study() {
				System.out.println("study");
			}
		});
	}
}