java基础7

一：形式参数问题
数据类型：
基本类型：byte,short,int,long,float,double,char,boolean
引用类型：类,接口,数组


形式参数：
基本类型：要的是该基本类型的数据值。
引用类型：要的是该引用类型的对象。
A:数组 要的是该数据类型数组的对象。(地址值)
B:类   要的是该类或者其子类的对象。(地址值)
C:抽象类 要的是该抽象类的子类对象。(地址值)
D:接口 要的是该接口的实现类对象。(地址值)




二：返回值问题
返回值：
基本类型：byte,short,int,long,float,double,char,boolean
引用类型：类，接口，数组


返回值之基本类型：
基本类型：返回的是该基本类型的数据值。
案例：创建一个加法的方法，返回值就是基本类型的具体的指

返回值之引用类型：
返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)
返回值是抽象类名：要的是该抽象类的子类对象。(地址值)
返回值是接口名：要的是该接口的实现类对象。(地址值)


三：权限修饰符（代码进行测试）
权限修饰符：在哪种情况下可以被访问到。
本类     同一个包下的类  不同包下的子类不同包下的无关类
private yes no no no
默认(什么都不写) yes yes no no
protected yes             yes      nono
public yes             yes yesyes




四：常见的内容修饰
1:常见的修饰

类：public
public class HelloWorld {}


成员变量：private
private String name;
private int age;


构造方法：public
public Student() {}
public Student(String name,int age) {}


成员方法：public
public void show() {}
public void eat() {}


2:哪些东西可以修饰哪些东西
   类 成员变量构造方法成员方法
private Y        Y Y
默认 YY       YY
protected Y Y Y
public Y Y YY
static Y Y
final YYY
abstract Y Y


注意：
四种权限修饰符，只能有一种存在。


class Demo {}


常见的组合：
类：
public class HelloWorld {}
public final class HelloWorld {}
public abstract class HelloWorld {}


成员变量：
private String name;
public final int X = 10;
public static int y = 20;
public static final int X = 30;

成员方法：
public void show(){}
public abstract void show();
public final void show(){}
public static void show() {}
public static final void show() {}


五：内部类
5.1
内部类：
把类A定义在类B的内部，类A就被称为内部类。


访问特点：（代码验证只要编译通过说明就是没有问题的）
A:内部类可以直接访问外部类的成员，包括私有。
B:外部类要访问内部类的成员，必须创建对象。


5.2
内部类分类：
成员位置：成员内部类
局部位置：局部内部类

5.2.1
成员内部类：
外界如何创建对象


外部类名.内部类名 对象名 = 外部类对象.内部类对象;


5.2.2
内部类的关键词限定：
内部类举例：
Body,Heart
//A:private 为了我们访问数据的安全性
class Body {
private class Heart {
public void operator() {
System.out.println("给心脏搭个桥");
}
}


public void method() {
if(你是医生吗?) {
Heart h = new Heart();
h.operator();
}
}
}


直接访问：
Body.Heart bh = new Body().new Heart();
bh.operator();


为了身体的安全，外界是不能让他们直接创建对象。通过private进行修饰。
这个时候就可以这样来使用：
Body b = new Body();
b.method();


成员内部类的修饰：
A:private 为了我们访问数据的安全性
B:static  为了我们访问数据的方便性


5.2.3
//B:static  为了我们访问数据的方便性
class Outer {


public static class Inner {
public void show() {
System.out.println("show");
}


public static void show2() {
System.out.println("show2");
}
}


}


class InnerClassDemo3 {
public static void main(String[] args) {
// 限定的新静态类
//Outer.Inner oi = new Outer().new Inner();
//格式：
Outer.Inner oi = new Outer.Inner();
oi.show();
oi.show2();


//Outer.Inner.show();
Outer.Inner.show2();
}
}


5.2.4
面试题：
/*
需求：请补齐代码，在控制台输出30,20,10
*/
class Outer {
public int num = 10;


private class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(？);//num
System.out.println(？);//this.num
System.out.println(？);//new Outer().num或者Outer.this.num
}
}


public void method() {
Inner i = new Inner();
i.show();
}
}


class InnerClassTest {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}



5.3
局部内部类：
A:可以直接访问外部类的成员，包括私有
B:在成员方法中创建局部内部类的对象，调用局部内部类的功能


面试题：
从内部类中访问本地变量number; 需要被声明为最终类型?


为什么：局部内部类访问局部变量必须加final修饰呢?
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

5.4
匿名内部类
没有名字的局部内部类,就是内部类的简化写法


前提：
存在一个类或者接口
这里的类可以是具体类也可以是抽象类。


格式：
new 类名或者接口名() {
重写方法;
};


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

5.5
匿名内部类在开发中的实际应用。
案例演示：传入的方法的参数是一个接口（方式一：定义一个已经实现了接口的类  方式二：匿名内部类的方式）


5.6面试题
/*
按照要求，补齐代码
interface Inter { void show(); }
class Outer { //补齐代码 }
class InnerClassTest {
public static void main(String[] args) {
 Outer.method().show();
 }
}
要求在控制台输出”HelloWorld”
*/
答案：
interface Inter { 
void show(); 
}


class Outer { 
//补齐代码
}


class InnerClassTest {
public static void main(String[] args) {
 Outer.method().show();
}
}

packagecom.edu_01;

public class ArgsDemo{

  public static voidmain(String[] args) {

    //在这里我们调用我们刚刚创建的数组遍历的方法

    //A:数组要的是该数据类型数组的对象。(地址值)

    //创建一个数组

    int[] arr = {1,2,3};

    printArr(arr);

  }

  //A:数组要的是该数据类型数组的对象。(地址值)

  //写一个方法是一个数组遍历的方法

  public static void printArr(int[] arr){

    for (int i = 0; i< arr.length; i++) {

      System.out.print(arr[i]+"  ");

    }

  }

}

packagecom.edu_01;

//B:类  要的是该类或者其子类的对象。(地址值)

class Person{

  public void show(){

    System.out.println("person的show方法");

  }

}

class Man extends Person{

  public voidfunction(){

    System.out.println("Man的function方法");

  }

}

classPersonDemo{

  //提供一个方法，这个方法的参数是Person

  public voidmethod(Person p){//Person p = new Person();

                  //当传递子类对象的时候，Person p= new Man();,这个是以多态的方式进行传参

    p.show();//p.show();

  }

}

public class ArgsDemo2{

  public static voidmain(String[] args) {

    //想要调用PersonDemo这个类中的method方法

    PersonDemo pd = newPersonDemo();

    //Person p = new Person();

    Man m = new Man();

    pd.method(m);

  }

}

packagecom.edu_01;

//C:抽象类要的是该抽象类的子类对象。(地址值)

abstract class Animal{

  public abstract void eat();

}

//创建一个Animal类的子类

class Dog extends Animal{

  @Override

  public void eat() {

    System.out.println("狗爱啃骨头");

  }

}

classAnimalDemo{

  public voidmethod(Animal a){//Aanimal a = new Dog();多态的方式进行传参

    //注意：如果一个形式参数类型是一个抽象类的话，本质上要的是这个抽象类的子类对象

    a.eat();

  }

}

public class ArgsDemo3{

  public static voidmain(String[] args) {

    //需要调用AnilaDemo这个类中的method这个方法

    AnimalDemo ad = newAnimalDemo();

    Animal a = new Dog();

    ad.method(a);

  }

}

packagecom.edu_01;

//D:接口要的是该接口的实现类对象。(地址值)

interface Person2{

  public abstract void eat();

}

class Women implements Person2{

  @Override

  public void eat() {

    System.out.println("民以食为天");

  }

}

classPerson2Demo{

  public voidmethod(Person2 p){//Perosn2 p = new Women();接口多态的方式进行传参

    //注意：如果一个方法的形式参数是一个接口类型的话，本质上需要的是这个接口的实现类对象，其实就是这个对象的地址值

    p.eat();

  }

}

public class ArgsDemo4{

  public static voidmain(String[] args) {

    //调用Peros2Demo中的method方法

    Person2Demo pd = newPerson2Demo();

    Person2 p = new Women();

    pd.method(p);

  }

}

packagecom.edu_02;

/**

 * 返回值之基本类型：

    基本类型：返回的是该基本类型的数据值。

    案例：创建一个加法的方法，返回值就是基本类型的具体的指

 */

public classRetrunDemo {

  public static voidmain(String[] args) {

    //调用这个家法

    System.out.println(add(1,2));

  }

  //创建一个方法，可以做两个数的加法，并返回两个数的和

  public static int add(int a,int b){

    return a+b;

  }

}

packagecom.edu_02;

//返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)

class Person{

  public void show(){

    System.out.println("perosn的show方法");

  }

}

class Student extends Person{

  public voidfunction(){

    System.out.println("Student的function方法");

  }

}

classPersonDemo{

  //有一个方法，方法的返回值就是一个Person类型

  public Person getPerson(){//Personp = new Person();

    //返回值类型如果是一个类名：本质上需要的是这个类或者这个类的子类对象

    //Person p = new Person();

    Student s = newStudent();//Person p = new Student();

    return s;

  }

 

}

 

public classReturnDemo2 {

  public static voidmain(String[] args) {

    //调用PersonDemo这个类中的getPerson()方法

    /*PersonDemo pd = newPersonDemo();

    Person p = pd.getPerson();//Person p = newPerson()

    p.show();*/

   

    PersonDemo pd = newPersonDemo();

    Person p = pd.getPerson();//Personp = new Studnet();,多态

    p.show();

    //p.function();

    Student s = (Student)p;

    s.function();

  }

}

packagecom.edu_02;

//返回值是抽象类名：要的是该抽象类的子类对象。(地址值)

abstract class Animal{

  public abstract void eat();

}

class Dog extends Animal{

  @Override

  public void eat() {

    System.out.println("狗就是爱吃骨头");

  }

}

 

classAnimalDemo{

  //提供以一个方法，这个方法的返回值类型就是一个抽象类名

  public Animal getAnimal(){//Animala = new Dog();

    //注意：返回值类型是一个抽象类名的话：本质上需要的是这个抽象类的子类对象

    //Animal a = new Dog();

    Dog a = new Dog();

    return a;

  }

}

public classReturnDemo3 {

  public static voidmain(String[] args) {

    //在这里调用ANimalDemo中的getAnimal的方法

    AnimalDemo ad = newAnimalDemo();

    Animal a = ad.getAnimal();//Animala = new Dog();

    a.eat();

  }

}

packagecom.edu_02;

//返回值是接口名：要的是该接口的实现类对象。(地址值)

//创建一个接口

interface Person2{

  public abstract void eat();

}

//创建一个类实现上面的接口

class Man implements Person2{

  @Override

  public void eat() {

    System.out.println("我爱吃泡馍");

  }

}

classPerson2Demo{

  //提供一个方法，该方法的返回值是一个接口类型

  //注意：如果一个方法的返回值是接口类型的话，本质上需要的是该接口的实现类对象

  public Person2getPerson2(){//Person2 p = new Man();

    Person2 p = new Man();

    return p;

  }

}

public classReturnDemo4 {

  public static voidmain(String[] args) {

    //调用Person2Demo中的getPersaon2()

    Person2Demo pd = newPerson2Demo();

    Person2 p = pd.getPerson2();//Person2p = new Man();,接口多态

    p.eat();

  }

}

packagecom.edu_03;

 

public class Fu {

  public static voidmain(String[] args) {

    //调用下面的四个方法

    Fu f = new Fu();

    f.show();

    f.show2();

    f.show3();

    f.show4();

  }

  //使用public修饰的show()

  public void show(){

    System.out.println("public");

  }

  //使用private修饰的show2()

  private void show2(){

    System.out.println("private");

  }

  //默认修饰符修饰的show3()方法

  void show3(){

    System.out.println("默认修饰符");

  }

  //使用protected修饰的show4()

  protected void show4(){

    System.out.println("protected");

  }

}

packagecom.edu_03;

 

public class Test {

  public static voidmain(String[] args) {

    //调用Fu类中的不同修饰符修饰的show方法

    Fu f = new Fu();

    f.show();

    f.show3();

    f.show4();

  }

}

packagecom.edu_04;

importcom.edu_03.Fu;

public class Test {

  public static voidmain(String[] args) {

    //创建Fu的对象，调用他的几个被不同的修饰符修饰的show方法

    Fu f = new Fu();

    f.show();

  }

}

packagecom.edu_04;

importcom.edu_03.Fu;

public class Zi extends Fu{

  public static voidmain(String[] args) {

    //创建Fu的对象，调用他的不同的修饰符修饰过的show方法

    Fu f = new Fu();

    f.show();

  }

}

packagecom.edu_05;

/**

  5.1

  内部类：

    把类A定义在类B的内部，类A就被称为内部类。

  访问特点：（代码验证只要编译通过说明就是没有问题的）

    A:内部类可以直接访问外部类的成员，包括私有。

    B:外部类要访问内部类的成员，必须创建对象。

 */

//创建一个外部类

class Outer{

  //私有画的成员变量

  private int num = 20;

  //创建一个内部类

  class Inner{

    //创建一个show方法，访问外部类的私有化的成员变量

    public void show(){

      System.out.println(num);//内部类的成员可以直接访问外部类的成员，包括私有

    }

  }

  //创建一个成员方法，访问内部类的show方法

  public voidfunction(){

    //创建内部类的对象，访问内部类的成员方法

    Inner i = new Inner();

    i.show();

  }

}

public classInnerClassDemo {

  public static voidmain(String[] args) {

    //创建一个外部类对象，调用他的function方法

    Outer o = new Outer();

    o.function();

  }

}

packagecom.edu_05;

/**

 * 5.2

  内部类分类：

    成员位置：成员内部类

    局部位置：局部内部类

 *

 */

//创建一个外部类

class Outer2{

  //创建一个成员内部类,位置在类中方法外，也就是类的成员位置

  class Inner2{}

  //创看一个局部内部类，位置位于方法内，也就是局部位置

  public void show(){

    //方法中存在一个类，叫局部内部类

    class Inner22{}

  }

}

public classInnerClassDemo2 {

}

packagecom.edu_05;

/**

 * 5.2.1

  成员内部类：

    外界如何创建对象

    外部类名.内部类名对象名 =外部类对象.内部类对象;

*/

class Outer3{

  //创建一个成员内部类

  class Inner3{

    public void show(){

      System.out.println("inner3的show()"); 

    }

  }

}

public classInnerClassDemo3 {

  public static voidmain(String[] args) {

    //需求：创建上面的内部类对象，调用他的show方法

    //创建内部类对象的格式：外部类名.内部类名    对象名 = 外部类对象.内部类对象

    Outer3.Inner3 oi = new Outer3().new Inner3();

    oi.show();

  }

}

packagecom.edu_05;

/**

 * 什么时候去使用内部类呢？

 * 答：当类与类之间存在一定的依附关系的时候我们就可以考虑使用内部类了。。

 * 举例：

 * Body,Heart

 * Computer,Cpu

 *

 * 当我们使用内部类的时候我们该使用什么修饰符进行修饰呢？

 * 1.使用private:作用是为了让我们的内部类隐藏具体的实现细节，让内部类更加安全，

 *   但是需要为内部类提供一个公共的外界访问方式

 */

class Body{

  //内部类Heart

  private class Heart{

    //有一个功能是可以做心脏搭桥手术的功能

    public void operator(){

      System.out.println("心脏可以做搭桥手术");

    }

  }

  //为了安全起见，我应该将内部类直接私有化，并在外部类中提供一个公共的访问方式

// public void method(){

//  if ("你是一个医生"){

//    //创建内部类对象，去做手术

//    Heart h = new Heart();

//    h.operator();

//  }

// }

}

public classInnerClassDemo4 {

  public static voidmain(String[] args) {

    //需求：现在我需要给我的心脏做一个搭桥手术

//  Body.Heart bh = new Body().new Heart();

//  bh.operator();

   //如果像上面这种做手术的方式的话，我们的心脏是极其不安全的，为什么？

    //因为当有外界想给我们的心脏做手术的时候，只需要去创建内部类对象就可以做手术了

    //但是这种手术不是谁都能做的，我们必须通过一些判断给予做手术的权力

  }

}

packagecom.edu_05;

* 内部类还可以使用什么修饰呢？

 * 2.还可以使用static修饰，一般配合public使用，这种修饰是为了提高代码访问的便捷性

 */

class Computer{

  //创建一个内部类

  public static class Cpu{

    public voidplayGame(){

      System.out.println("cpu强悍的电脑可以玩耍大型游戏");

    }

    public static void show(){

      System.out.println("cpu的static方法");

    }

  }

}

public classInnerClassDemo5 {

  public static voidmain(String[] args) {

    //需求：调用内部类的playGame()

//  Computer.Cpu cc = new Computer().new Cpu();

//  cc.playGame();

    //注意：如果内部类是静态的，则不能使用上面的创建对象的方式创建内部类对象了

    Computer.Cpu cc = newComputer.Cpu();

    cc.playGame();

    cc.show();

   

    System.out.println("------------------");

    //通过类名直接访问我的静态内部类的静态方法

    Computer.Cpu.show();

  }

 

}

packagecom.edu_05;

class Outerr {

  public int num = 10;

  private class Inner {

    public int num = 20;

    public void show() {

      int num = 30;

      System.out.println(num);//num

  System.out.println(this.num);//this.num

      System.out.println(new Outerr().num);//或者Outer.this.num

    }

  }

  public void method(){

    Inner i = new Inner();

    i.show();

  }

}

classInnerClassTest {

  public static voidmain(String[] args) {

    Outerr o = new Outerr();

    o.method();

  }

}

packagecom.edu_06;

/**

 * 5.3

  局部内部类：

  A:可以直接访问外部类的成员，包括私有

  B:在成员方法中创建局部内部类的对象，调用局部内部类的功能

 *

 */

class Outer{

  //创建一个外部类的私有化的成员变量

  private int num = 30;

  //创建一个show方法，show方法内部有一个局部内部类

  public void show(){

    //设置一个show方法的局部变量

    final int num2 =40;//num2被加上final之后，num2变成了常量，其实本质上他就是40

    //创建局部内部类

    class Inner{

      //存在一个function方法

      public voidfunction(){

         System.out.println(num2);

         //System.out.println(40);

         //编译：java -- class

         //反编译：class -- java

         /**

          * 问题：局部内部类的成员方法访问局部变量的时候，局部变量为什么必须加上final就不报错了呢？？

          * 我们的show方法在调用的时候存在于栈内存，当show方法调用完毕之后，他的局部变量num2会随着show

          * 方法调用完毕二消失，但是现在存在一个问题，show方法中的局部对象不会立即从栈内存中直接释放掉，他还保留着num2,

          * 此时就发生了矛盾，局部对象想使用这个num2这个变量，但是他又急着从栈内存中消失。。。，所以我们需要给num2加上final关键字

          * 是他变为常量

          */

      }

    }

    //需求：在show方法中调用局部内部类的function方法

    //创建局部内部类对象

    Inner i = new Inner();

    i.function();

  }

}

public classInnerClassDemo {

  public static voidmain(String[] args) {

    //需求：调用Outer外部类的show方法

    //创建外部类对象

    Outer o = new Outer();

    o.show();

  }

}

packagecom.edu_06;

/**

 * 5.4

  匿名内部类

    没有名字的局部内部类,就是内部类的简化写法

  前提：

    存在一个类或者接口

    这里的类可以是具体类也可以是抽象类。

  格式：

    new 类名或者接口名() {

      重写方法;

    };

  本质：

    是一个继承了类或者实现了接口的子类匿名对象。

  */

//创建一个接口

interface Animal{

  public abstract void eat();

}

//创建一个外部类

class Outer2{

  //创建一个show方法，方法中存在一个匿名内部类

  public void show(){

    //匿名内部类

    //匿名内部类格式：new类或者接口(){重写的方法}

    //匿名内部类本质：就是一个继承了类，或者实现了接口，的子类或者实现类的匿名对象

    new Animal(){

      @Override

      public void eat() {

         System.out.println("动物爱吃肉");

      }

    }.eat();

  }

}

public classInnerClassDemo2 {

  public static voidmain(String[] args) {

    //创建一个Outer2这个外部类对象

    Outer2 o2 = new Outer2();

    o2.show();

  }

}

packagecom.edu_06;

 

interface Person{

  public abstract void eat();

}

//创建一个接口的实现类

class Man implements Person{

  @Override

  public void eat() {

    System.out.println("民以食为天");

  }

}

classPersonDemo{

  public voidshow(Person p){

    p.eat();

  }

}

public classInnerClassDemo3 {

  public static voidmain(String[] args) {

    //创建PersonDemo对象

    PersonDemo pd = newPersonDemo();

    //如果一个方法的参数是一个接口的话，本质上要的是这个接口的实现类对象

    pd.show(new Man());

  }

}

packagecom.edu_06;

/**

 * 5.5

  匿名内部类在开发中的实际应用。

  案例演示：传入的方法的参数是一个接口（方式一：定义一个已经实现了接口的类 方式二：匿名内部类的方式）

 */

interface Person2{

  public abstract void eat();

}

class Man2 implements Person2{

  @Override

  public void eat() {

    System.out.println("男人都爱吃泡馍");

  }

}

 

classPerson2Demo{

  //创建一个方法，方法的参数是一个接口类型

  public voidshow(Person2 p){

    p.eat();

  }

}

public classInnerClassDemo4 {

  public static voidmain(String[] args) {

    //调用Person2Demo中的show方法

    Person2Demo pd2 = newPerson2Demo();

    pd2.show(new Man2());//传入接口的实现类对象

    System.out.println("--------------------");

    //使用匿名内部类的方式进行传参

    pd2.show(newPerson2(){//这里的匿名内部类，本质上就是实现了Person2这个接口的一个实现类对应的匿名对象

      @Override

      public void eat() {

         System.out.println("我爱吃油泼面");

      }

    });

  }

}

 

packagecom.edu_07;

//要求在控制台输出”HelloWorld”

interface Inter { void show(); }

 

class Outer {

  //补齐代码

  //创建method()是静态的

  public static Intermethod(){

    return new Inter(){

      @Override

      public void show() {

         System.out.println("helloworld");

      }};

  }

 

}

 

classInnerClassTest {

  public static voidmain(String[] args) {

     Outer.method().show();

      /**

       *1.method()这个方法如果可以直接通过类名实现调用的话，说明这个方法是static

       *2.Outer.method()可以紧接着调用show()说明method方法的返回值一定是一个Inter接口的实现类对象

       *3.所以这个实现类对象我们可以直接使用匿名内部类的形式去进行实现，因为匿名内部类的本质就是实现了Inter接口的一个实现类匿名对象

       */

    }

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

packagecom.edu_01;

public class ArgsDemo{

  public static voidmain(String[] args) {

    //在这里我们调用我们刚刚创建的数组遍历的方法

    //A:数组要的是该数据类型数组的对象。(地址值)

    //创建一个数组

    int[] arr = {1,2,3};

    printArr(arr);

  }

  //A:数组要的是该数据类型数组的对象。(地址值)

  //写一个方法是一个数组遍历的方法

  public static void printArr(int[] arr){

    for (int i = 0; i< arr.length; i++) {

      System.out.print(arr[i]+"  ");

    }

  }

}

packagecom.edu_01;

//B:类  要的是该类或者其子类的对象。(地址值)

class Person{

  public void show(){

    System.out.println("person的show方法");

  }

}

class Man extends Person{

  public voidfunction(){

    System.out.println("Man的function方法");

  }

}

classPersonDemo{

  //提供一个方法，这个方法的参数是Person

  public voidmethod(Person p){//Person p = new Person();

                  //当传递子类对象的时候，Person p= new Man();,这个是以多态的方式进行传参

    p.show();//p.show();

  }

}

public class ArgsDemo2{

  public static voidmain(String[] args) {

    //想要调用PersonDemo这个类中的method方法

    PersonDemo pd = newPersonDemo();

    //Person p = new Person();

    Man m = new Man();

    pd.method(m);

  }

}

packagecom.edu_01;

//C:抽象类要的是该抽象类的子类对象。(地址值)

abstract class Animal{

  public abstract void eat();

}

//创建一个Animal类的子类

class Dog extends Animal{

  @Override

  public void eat() {

    System.out.println("狗爱啃骨头");

  }

}

classAnimalDemo{

  public voidmethod(Animal a){//Aanimal a = new Dog();多态的方式进行传参

    //注意：如果一个形式参数类型是一个抽象类的话，本质上要的是这个抽象类的子类对象

    a.eat();

  }

}

public class ArgsDemo3{

  public static voidmain(String[] args) {

    //需要调用AnilaDemo这个类中的method这个方法

    AnimalDemo ad = newAnimalDemo();

    Animal a = new Dog();

    ad.method(a);

  }

}

packagecom.edu_01;

//D:接口要的是该接口的实现类对象。(地址值)

interface Person2{

  public abstract void eat();

}

class Women implements Person2{

  @Override

  public void eat() {

    System.out.println("民以食为天");

  }

}

classPerson2Demo{

  public voidmethod(Person2 p){//Perosn2 p = new Women();接口多态的方式进行传参

    //注意：如果一个方法的形式参数是一个接口类型的话，本质上需要的是这个接口的实现类对象，其实就是这个对象的地址值

    p.eat();

  }

}

public class ArgsDemo4{

  public static voidmain(String[] args) {

    //调用Peros2Demo中的method方法

    Person2Demo pd = newPerson2Demo();

    Person2 p = new Women();

    pd.method(p);

  }

}

packagecom.edu_02;

/**

 * 返回值之基本类型：

    基本类型：返回的是该基本类型的数据值。

    案例：创建一个加法的方法，返回值就是基本类型的具体的指

 */

public classRetrunDemo {

  public static voidmain(String[] args) {

    //调用这个家法

    System.out.println(add(1,2));

  }

  //创建一个方法，可以做两个数的加法，并返回两个数的和

  public static int add(int a,int b){

    return a+b;

  }

}

packagecom.edu_02;

//返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)

class Person{

  public void show(){

    System.out.println("perosn的show方法");

  }

}

class Student extends Person{

  public voidfunction(){

    System.out.println("Student的function方法");

  }

}

classPersonDemo{

  //有一个方法，方法的返回值就是一个Person类型

  public Person getPerson(){//Personp = new Person();

    //返回值类型如果是一个类名：本质上需要的是这个类或者这个类的子类对象

    //Person p = new Person();

    Student s = newStudent();//Person p = new Student();

    return s;

  }

 

}

 

public classReturnDemo2 {

  public static voidmain(String[] args) {

    //调用PersonDemo这个类中的getPerson()方法

    /*PersonDemo pd = newPersonDemo();

    Person p = pd.getPerson();//Person p = newPerson()

    p.show();*/

   

    PersonDemo pd = newPersonDemo();

    Person p = pd.getPerson();//Personp = new Studnet();,多态

    p.show();

    //p.function();

    Student s = (Student)p;

    s.function();

  }

}

packagecom.edu_02;

//返回值是抽象类名：要的是该抽象类的子类对象。(地址值)

abstract class Animal{

  public abstract void eat();

}

class Dog extends Animal{

  @Override

  public void eat() {

    System.out.println("狗就是爱吃骨头");

  }

}

 

classAnimalDemo{

  //提供以一个方法，这个方法的返回值类型就是一个抽象类名

  public Animal getAnimal(){//Animala = new Dog();

    //注意：返回值类型是一个抽象类名的话：本质上需要的是这个抽象类的子类对象

    //Animal a = new Dog();

    Dog a = new Dog();

    return a;

  }

}

public classReturnDemo3 {

  public static voidmain(String[] args) {

    //在这里调用ANimalDemo中的getAnimal的方法

    AnimalDemo ad = newAnimalDemo();

    Animal a = ad.getAnimal();//Animala = new Dog();

    a.eat();

  }

}

packagecom.edu_02;

//返回值是接口名：要的是该接口的实现类对象。(地址值)

//创建一个接口

interface Person2{

  public abstract void eat();

}

//创建一个类实现上面的接口

class Man implements Person2{

  @Override

  public void eat() {

    System.out.println("我爱吃泡馍");

  }

}

classPerson2Demo{

  //提供一个方法，该方法的返回值是一个接口类型

  //注意：如果一个方法的返回值是接口类型的话，本质上需要的是该接口的实现类对象

  public Person2getPerson2(){//Person2 p = new Man();

    Person2 p = new Man();

    return p;

  }

}

public classReturnDemo4 {

  public static voidmain(String[] args) {

    //调用Person2Demo中的getPersaon2()

    Person2Demo pd = newPerson2Demo();

    Person2 p = pd.getPerson2();//Person2p = new Man();,接口多态

    p.eat();

  }

}

packagecom.edu_03;

 

public class Fu {

  public static voidmain(String[] args) {

    //调用下面的四个方法

    Fu f = new Fu();

    f.show();

    f.show2();

    f.show3();

    f.show4();

  }

  //使用public修饰的show()

  public void show(){

    System.out.println("public");

  }

  //使用private修饰的show2()

  private void show2(){

    System.out.println("private");

  }

  //默认修饰符修饰的show3()方法

  void show3(){

    System.out.println("默认修饰符");

  }

  //使用protected修饰的show4()

  protected void show4(){

    System.out.println("protected");

  }

}

packagecom.edu_03;

 

public class Test {

  public static voidmain(String[] args) {

    //调用Fu类中的不同修饰符修饰的show方法

    Fu f = new Fu();

    f.show();

    f.show3();

    f.show4();

  }

}

packagecom.edu_04;

importcom.edu_03.Fu;

public class Test {

  public static voidmain(String[] args) {

    //创建Fu的对象，调用他的几个被不同的修饰符修饰的show方法

    Fu f = new Fu();

    f.show();

  }

}

packagecom.edu_04;

importcom.edu_03.Fu;

public class Zi extends Fu{

  public static voidmain(String[] args) {

    //创建Fu的对象，调用他的不同的修饰符修饰过的show方法

    Fu f = new Fu();

    f.show();

  }

}

packagecom.edu_05;

/**

  5.1

  内部类：

    把类A定义在类B的内部，类A就被称为内部类。

  访问特点：（代码验证只要编译通过说明就是没有问题的）

    A:内部类可以直接访问外部类的成员，包括私有。

    B:外部类要访问内部类的成员，必须创建对象。

 */

//创建一个外部类

class Outer{

  //私有画的成员变量

  private int num = 20;

  //创建一个内部类

  class Inner{

    //创建一个show方法，访问外部类的私有化的成员变量

    public void show(){

      System.out.println(num);//内部类的成员可以直接访问外部类的成员，包括私有

    }

  }

  //创建一个成员方法，访问内部类的show方法

  public voidfunction(){

    //创建内部类的对象，访问内部类的成员方法

    Inner i = new Inner();

    i.show();

  }

}

public classInnerClassDemo {

  public static voidmain(String[] args) {

    //创建一个外部类对象，调用他的function方法

    Outer o = new Outer();

    o.function();

  }

}

packagecom.edu_05;

/**

 * 5.2

  内部类分类：

    成员位置：成员内部类

    局部位置：局部内部类

 *

 */

//创建一个外部类

class Outer2{

  //创建一个成员内部类,位置在类中方法外，也就是类的成员位置

  class Inner2{}

  //创看一个局部内部类，位置位于方法内，也就是局部位置

  public void show(){

    //方法中存在一个类，叫局部内部类

    class Inner22{}

  }

}

public classInnerClassDemo2 {

}

packagecom.edu_05;

/**

 * 5.2.1

  成员内部类：

    外界如何创建对象

    外部类名.内部类名对象名 =外部类对象.内部类对象;

*/

class Outer3{

  //创建一个成员内部类

  class Inner3{

    public void show(){

      System.out.println("inner3的show()"); 

    }

  }

}

public classInnerClassDemo3 {

  public static voidmain(String[] args) {

    //需求：创建上面的内部类对象，调用他的show方法

    //创建内部类对象的格式：外部类名.内部类名    对象名 = 外部类对象.内部类对象

    Outer3.Inner3 oi = new Outer3().new Inner3();

    oi.show();

  }

}

packagecom.edu_05;

/**

 * 什么时候去使用内部类呢？

 * 答：当类与类之间存在一定的依附关系的时候我们就可以考虑使用内部类了。。

 * 举例：

 * Body,Heart

 * Computer,Cpu

 *

 * 当我们使用内部类的时候我们该使用什么修饰符进行修饰呢？

 * 1.使用private:作用是为了让我们的内部类隐藏具体的实现细节，让内部类更加安全，

 *   但是需要为内部类提供一个公共的外界访问方式

 */

class Body{

  //内部类Heart

  private class Heart{

    //有一个功能是可以做心脏搭桥手术的功能

    public void operator(){

      System.out.println("心脏可以做搭桥手术");

    }

  }

  //为了安全起见，我应该将内部类直接私有化，并在外部类中提供一个公共的访问方式

// public void method(){

//  if ("你是一个医生"){

//    //创建内部类对象，去做手术

//    Heart h = new Heart();

//    h.operator();

//  }

// }

}

public classInnerClassDemo4 {

  public static voidmain(String[] args) {

    //需求：现在我需要给我的心脏做一个搭桥手术

//  Body.Heart bh = new Body().new Heart();

//  bh.operator();

   //如果像上面这种做手术的方式的话，我们的心脏是极其不安全的，为什么？

    //因为当有外界想给我们的心脏做手术的时候，只需要去创建内部类对象就可以做手术了

    //但是这种手术不是谁都能做的，我们必须通过一些判断给予做手术的权力

  }

}

packagecom.edu_05;

* 内部类还可以使用什么修饰呢？

 * 2.还可以使用static修饰，一般配合public使用，这种修饰是为了提高代码访问的便捷性

 */

class Computer{

  //创建一个内部类

  public static class Cpu{

    public voidplayGame(){

      System.out.println("cpu强悍的电脑可以玩耍大型游戏");

    }

    public static void show(){

      System.out.println("cpu的static方法");

    }

  }

}

public classInnerClassDemo5 {

  public static voidmain(String[] args) {

    //需求：调用内部类的playGame()

//  Computer.Cpu cc = new Computer().new Cpu();

//  cc.playGame();

    //注意：如果内部类是静态的，则不能使用上面的创建对象的方式创建内部类对象了

    Computer.Cpu cc = newComputer.Cpu();

    cc.playGame();

    cc.show();

   

    System.out.println("------------------");

    //通过类名直接访问我的静态内部类的静态方法

    Computer.Cpu.show();

  }

 

}

packagecom.edu_05;

class Outerr {

  public int num = 10;

  private class Inner {

    public int num = 20;

    public void show() {

      int num = 30;

      System.out.println(num);//num

  System.out.println(this.num);//this.num

      System.out.println(new Outerr().num);//或者Outer.this.num

    }

  }

  public void method(){

    Inner i = new Inner();

    i.show();

  }

}

classInnerClassTest {

  public static voidmain(String[] args) {

    Outerr o = new Outerr();

    o.method();

  }

}

packagecom.edu_06;

/**

 * 5.3

  局部内部类：

  A:可以直接访问外部类的成员，包括私有

  B:在成员方法中创建局部内部类的对象，调用局部内部类的功能

 *

 */

class Outer{

  //创建一个外部类的私有化的成员变量

  private int num = 30;

  //创建一个show方法，show方法内部有一个局部内部类

  public void show(){

    //设置一个show方法的局部变量

    final int num2 =40;//num2被加上final之后，num2变成了常量，其实本质上他就是40

    //创建局部内部类

    class Inner{

      //存在一个function方法

      public voidfunction(){

         System.out.println(num2);

         //System.out.println(40);

         //编译：java -- class

         //反编译：class -- java

         /**

          * 问题：局部内部类的成员方法访问局部变量的时候，局部变量为什么必须加上final就不报错了呢？？

          * 我们的show方法在调用的时候存在于栈内存，当show方法调用完毕之后，他的局部变量num2会随着show

          * 方法调用完毕二消失，但是现在存在一个问题，show方法中的局部对象不会立即从栈内存中直接释放掉，他还保留着num2,

          * 此时就发生了矛盾，局部对象想使用这个num2这个变量，但是他又急着从栈内存中消失。。。，所以我们需要给num2加上final关键字

          * 是他变为常量

          */

      }

    }

    //需求：在show方法中调用局部内部类的function方法

    //创建局部内部类对象

    Inner i = new Inner();

    i.function();

  }

}

public classInnerClassDemo {

  public static voidmain(String[] args) {

    //需求：调用Outer外部类的show方法

    //创建外部类对象

    Outer o = new Outer();

    o.show();

  }

}

packagecom.edu_06;

/**

 * 5.4

  匿名内部类

    没有名字的局部内部类,就是内部类的简化写法

  前提：

    存在一个类或者接口

    这里的类可以是具体类也可以是抽象类。

  格式：

    new 类名或者接口名() {

      重写方法;

    };

  本质：

    是一个继承了类或者实现了接口的子类匿名对象。

  */

//创建一个接口

interface Animal{

  public abstract void eat();

}

//创建一个外部类

class Outer2{

  //创建一个show方法，方法中存在一个匿名内部类

  public void show(){

    //匿名内部类

    //匿名内部类格式：new类或者接口(){重写的方法}

    //匿名内部类本质：就是一个继承了类，或者实现了接口，的子类或者实现类的匿名对象

    new Animal(){

      @Override

      public void eat() {

         System.out.println("动物爱吃肉");

      }

    }.eat();

  }

}

public classInnerClassDemo2 {

  public static voidmain(String[] args) {

    //创建一个Outer2这个外部类对象

    Outer2 o2 = new Outer2();

    o2.show();

  }

}

packagecom.edu_06;

 

interface Person{

  public abstract void eat();

}

//创建一个接口的实现类

class Man implements Person{

  @Override

  public void eat() {

    System.out.println("民以食为天");

  }

}

classPersonDemo{

  public voidshow(Person p){

    p.eat();

  }

}

public classInnerClassDemo3 {

  public static voidmain(String[] args) {

    //创建PersonDemo对象

    PersonDemo pd = newPersonDemo();

    //如果一个方法的参数是一个接口的话，本质上要的是这个接口的实现类对象

    pd.show(new Man());

  }

}

packagecom.edu_06;

/**

 * 5.5

  匿名内部类在开发中的实际应用。

  案例演示：传入的方法的参数是一个接口（方式一：定义一个已经实现了接口的类 方式二：匿名内部类的方式）

 */

interface Person2{

  public abstract void eat();

}

class Man2 implements Person2{

  @Override

  public void eat() {

    System.out.println("男人都爱吃泡馍");

  }

}

 

classPerson2Demo{

  //创建一个方法，方法的参数是一个接口类型

  public voidshow(Person2 p){

    p.eat();

  }

}

public classInnerClassDemo4 {

  public static voidmain(String[] args) {

    //调用Person2Demo中的show方法

    Person2Demo pd2 = newPerson2Demo();

    pd2.show(new Man2());//传入接口的实现类对象

    System.out.println("--------------------");

    //使用匿名内部类的方式进行传参

    pd2.show(newPerson2(){//这里的匿名内部类，本质上就是实现了Person2这个接口的一个实现类对应的匿名对象

      @Override

      public void eat() {

         System.out.println("我爱吃油泼面");

      }

    });

  }

}

 

packagecom.edu_07;

//要求在控制台输出”HelloWorld”

interface Inter { void show(); }

 

class Outer {

  //补齐代码

  //创建method()是静态的

  public static Intermethod(){

    return new Inter(){

      @Override

      public void show() {

         System.out.println("helloworld");

      }};

  }

 

}

 

classInnerClassTest {

  public static voidmain(String[] args) {

     Outer.method().show();

      /**

       *1.method()这个方法如果可以直接通过类名实现调用的话，说明这个方法是static

       *2.Outer.method()可以紧接着调用show()说明method方法的返回值一定是一个Inter接口的实现类对象

       *3.所以这个实现类对象我们可以直接使用匿名内部类的形式去进行实现，因为匿名内部类的本质就是实现了Inter接口的一个实现类匿名对象

       */

    }

}