Java学习【知识点及代码7】

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

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

package com.edu_01;

public class ArgsDemo {
    public static void main(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]+"  ");
        }
    }
}

package com.edu_01;
//B:类   要的是该类或者其子类的对象。(地址值)
class Person{
    public void show(){
        System.out.println("person的show方法");
    }
}

class Man extends Person{
    public void function(){
        System.out.println("Man的function方法");
    }
}

class PersonDemo{
    //提供一个方法，这个方法的参数是Person
    public void method(Person p){//Person p = new Person();
                                 //当传递子类对象的时候，Person p = new Man();,这个是以多态的方式进行传参
        p.show();//p.show();
    }
}

public class ArgsDemo2 {
    public static void main(String[] args) {
        //想要调用PersonDemo这个类中的method方法
        PersonDemo pd = new PersonDemo();
        //Person p = new Person();
        Man m = new Man();
        pd.method(m);
    }
}

package com.edu_01;
//C:抽象类 要的是该抽象类的子类对象。(地址值)
abstract class Animal{
    public abstract void eat();
}

//创建一个Animal类的子类
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗爱啃骨头");
    }

}

class AnimalDemo{
    public void method(Animal a){//Aanimal a = new Dog();多态的方式进行传参
        //注意：如果一个形式参数类型是一个抽象类的话，本质上要的是这个抽象类的子类对象
        a.eat();
    }
}


public class ArgsDemo3 {
    public static void main(String[] args) {
        //需要调用AnilaDemo这个类中的method这个方法
        AnimalDemo ad = new AnimalDemo();
        Animal a = new Dog();
        ad.method(a);
    }
}

package com.edu_01;
//D:接口  要的是该接口的实现类对象。(地址值)
interface Person2{
    public abstract void eat();
}

class Women implements Person2{
    @Override
    public void eat() {
        System.out.println("民以食为天");
    }
}

class Person2Demo{
    public void method(Person2 p){//Perosn2 p = new Women();接口多态的方式进行传参
        //注意：如果一个方法的形式参数是一个接口类型的话，本质上需要的是这个接口的实现类对象，其实就是这个对象的地址值
        p.eat();
    }
}

public class ArgsDemo4 {
    public static void main(String[] args) {
        //调用Peros2Demo中的method方法
        Person2Demo pd = new Person2Demo();
        Person2 p = new Women();
        pd.method(p);
    }
}

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

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

package com.edu_02;
public class RetrunDemo {
    public static void main(String[] args) {
        //调用这个家法
        System.out.println(add(1, 2));
    }

    //创建一个方法，可以做两个数的加法，并返回两个数的和
    public static int add(int a,int b){
        return a+b;
    }   
}

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

package com.edu_02;
//返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)
class Person{
    public void show(){
        System.out.println("perosn的show方法");
    }
}

class Student extends Person{
    public void function(){
        System.out.println("Student的function方法");
    }
}

class PersonDemo{
    //有一个方法，方法的返回值就是一个Person类型
    public Person getPerson(){//Person p = new Person();
        //返回值类型如果是一个类名：本质上需要的是这个类或者这个类的子类对象
        //Person p = new Person();
        Student s = new Student();//Person p = new Student();
        return s;
    }

}

public class ReturnDemo2 {
    public static void main(String[] args) {
        //调用PersonDemo这个类中的getPerson()方法
        /*PersonDemo pd = new PersonDemo();
        Person p = pd.getPerson();//Person p = new Person()
        p.show();*/

        PersonDemo pd = new PersonDemo();
        Person p = pd.getPerson();//Person p = new Studnet();,多态
        p.show();
        //p.function();
        Student s = (Student)p;
        s.function();
    }
}

package com.edu_02;
//返回值是抽象类名：要的是该抽象类的子类对象。(地址值)
abstract class Animal{
    public abstract void eat();
}

class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗就是爱吃骨头");
    }
}

class AnimalDemo{
    //提供以一个方法，这个方法的返回值类型就是一个抽象类名
    public Animal getAnimal(){//Animal a = new Dog();
        //注意：返回值类型是一个抽象类名的话：本质上需要的是这个抽象类的子类对象
        //Animal a = new Dog();
        Dog a = new Dog();
        return a;
    }

}


public class ReturnDemo3 {
    public static void main(String[] args) {
        //在这里调用ANimalDemo中的getAnimal的方法
        AnimalDemo ad = new AnimalDemo();
        Animal a = ad.getAnimal();//Animal a = new Dog();
        a.eat();
    }
}

package com.edu_02;
//返回值是接口名：要的是该接口的实现类对象。(地址值)
//创建一个接口
interface Person2{
    public abstract void eat();
}

//创建一个类实现上面的接口
class Man implements Person2{
    @Override
    public void eat() {
        System.out.println("我爱吃泡馍");
    }
}


class Person2Demo{
    //提供一个方法，该方法的返回值是一个接口类型
    //注意：如果一个方法的返回值是接口类型的话，本质上需要的是该接口的实现类对象
    public Person2 getPerson2(){//Person2 p = new Man();
        Person2 p = new Man();
        return p;
    }
}

public class ReturnDemo4 {
    public static void main(String[] args) {
        //调用Person2Demo中的getPersaon2()
        Person2Demo pd = new Person2Demo();
        Person2 p = pd.getPerson2();//Person2 p = new Man();,接口多态
        p.eat();
    }
}

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

package com.edu_03;

public class Fu {
    public static void main(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");
    }
}

package com.edu_03;

public class Test {
    public static void main(String[] args) {
        //调用Fu类中的不同修饰符修饰的show方法
        Fu f = new Fu();
        f.show();
        f.show3();
        f.show4();
    }
}

package com.edu_04;

import com.edu_03.Fu;

public class Zi extends Fu{
    public static void main(String[] args) {
        //创建Fu的对象，调用他的不同的修饰符修饰过的show方法
        Fu f = new Fu();
        f.show();
    }
}

package com.edu_04;

import com.edu_03.Fu;

public class Test {
    public static void main(String[] args) {
        //创建Fu的对象，调用他的几个被不同的修饰符修饰的show方法
        Fu f = new Fu();
        f.show();
    }
}

四：常见的内容修饰
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 N Y Y Y
默认 Y Y Y Y
protected N Y Y Y
public Y Y Y Y
static N Y N Y
final Y Y N Y
abstract Y N N 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:外部类要访问内部类的成员，必须创建对象。

package com.edu_05;
//创建一个外部类
class Outer{
    //私有画的成员变量
    private int num = 20;

    //创建一个内部类
    class Inner{
        //创建一个show方法，访问外部类的私有化的成员变量
        public void show(){
            System.out.println(num);//内部类的成员可以直接访问外部类的成员，包括私有
        }
    }

    //创建一个成员方法，访问内部类的show方法
    public void function(){
        //创建内部类的对象，访问内部类的成员方法
        Inner i = new Inner();
        i.show();
    }
}

public class InnerClassDemo {
    public static void main(String[] args) {
        //创建一个外部类对象，调用他的function方法
        Outer o = new Outer();
        o.function();
    }
}

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

package com.edu_05;
//创建一个外部类
class Outer2{
    //创建一个成员内部类,位置在类中方法外，也就是类的成员位置
    class Inner2{}

    //创看一个局部内部类，位置位于方法内，也就是局部位置
    public void show(){
        //方法中存在一个类，叫局部内部类
        class Inner22{}
    }

}

public class InnerClassDemo2 {

}

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

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

package com.edu_05;
class Outer3{
    //创建一个成员内部类
    class Inner3{
        public void show(){
            System.out.println("inner3的show()");    
        }
    }

}

public class InnerClassDemo3 {
    public static void main(String[] args) {
        //需求：创建上面的内部类对象，调用他的show方法
        //创建内部类对象的格式：外部类名.内部类名     对象名 = 外部类对象.内部类对象
        Outer3.Inner3 oi = new Outer3().new Inner3(); 
        oi.show();
    }
}

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();
    }
}

package com.edu_05;
class Computer{
    //创建一个内部类
    public static class Cpu{
        public void playGame(){
            System.out.println("cpu强悍的电脑可以玩耍大型游戏");
        }

        public static void show(){
            System.out.println("cpu的static方法"); 
        }
    }
}


public class InnerClassDemo5 {
    public static void main(String[] args) {
        //需求：调用内部类的playGame()
//      Computer.Cpu cc = new Computer().new Cpu();
//      cc.playGame();
        //注意：如果内部类是静态的，则不能使用上面的创建对象的方式创建内部类对象了

        Computer.Cpu cc = new Computer.Cpu();
        cc.playGame();
        cc.show();

        System.out.println("------------------");
        //通过类名直接访问我的静态内部类的静态方法
        Computer.Cpu.show();
    }
}

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修饰，这样，在堆内存里面存储的其实是一个常量值。

package com.edu_06;
class Outer{
    //创建一个外部类的私有化的成员变量
    private int num = 30;

    //创建一个show方法，show方法内部有一个局部内部类
    public void show(){
        //设置一个show方法的局部变量
        final int num2 = 40;//num2被加上final之后，num2变成了常量，其实本质上他就是40
        //创建局部内部类
        class Inner{
            //存在一个function方法
            public void function(){
                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 class InnerClassDemo {
    public static void main(String[] args) {
        //需求：调用Outer外部类的show方法
        //创建外部类对象
        Outer o = new Outer();
        o.show();
    }
}

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

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

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

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

package com.edu_06;
//创建一个接口
interface Animal{
    public abstract void eat();
}

//创建一个外部类
class Outer2{
    //创建一个show方法，方法中存在一个匿名内部类
    public void show(){
        //匿名内部类
        //匿名内部类格式：new 类或者接口(){重写的方法}
        //匿名内部类本质：就是一个继承了类 ，或者实现了接口 ，的子类或者实现类的匿名对象
        new Animal(){
            @Override
            public void eat() {
                System.out.println("动物爱吃肉");
            }   
        }.eat();
    }
}


public class InnerClassDemo2 {
    public static void main(String[] args) {
        //创建一个Outer2这个外部类对象
        Outer2 o2 = new Outer2();
        o2.show();
    }

}

package com.edu_06;

interface Person{
    public abstract void eat();
}

//创建一个接口的实现类
class Man implements Person{
    @Override
    public void eat() {
        System.out.println("民以食为天");
    }

}

class PersonDemo{
    public void show(Person p){
        p.eat();
    }
}


public class InnerClassDemo3 {
    public static void main(String[] args) {
        //创建PersonDemo对象
        PersonDemo pd = new PersonDemo();
        //如果一个方法的参数是一个接口的话，本质上要的是这个接口的实现类对象
        pd.show(new Man());
    }
}

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

package com.edu_06;
interface Person2{
    public abstract void eat();
}

class Man2 implements Person2{
    @Override
    public void eat() {
        System.out.println("男人都爱吃泡馍");
    }
}

class Person2Demo{
    //创建一个方法，方法的参数是一个接口类型
    public void show(Person2 p){
        p.eat();
    }
}

public class InnerClassDemo4 {
    public static void main(String[] args) {
        //调用Person2Demo中的show方法
        Person2Demo pd2 = new Person2Demo();
        pd2.show(new Man2());//传入接口的实现类对象

        System.out.println("--------------------");
        //使用匿名内部类的方式进行传参
        pd2.show(new Person2(){//这里的匿名内部类，本质上就是实现了Person2这个接口的一个实现类对应的匿名对象
            @Override
            public void eat() {
                System.out.println("我爱吃油泼面");
            }
        });
    }
}

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

package com.edu_07;
//要求在控制台输出”HelloWorld”
interface Inter { void show(); }

class Outer { 
    //补齐代码 
    //创建method()是静态的
    public static Inter method(){
        return new Inter(){
            @Override
            public void show() {
                System.out.println("helloworld");
            }};
    }   
}

class InnerClassTest {
    public static void main(String[] args) {
          Outer.method().show();
          /**
           * 1.method()这个方法如果可以直接通过类名实现调用的话，说明这个方法是static
           * 2.Outer.method()可以紧接着调用show()说明method方法的返回值一定是一个Inter接口的实现类对象
           * 3.所以这个实现类对象我们可以直接使用匿名内部类的形式去进行实现，因为匿名内部类的本质就是实现了Inter接口的一个实现类匿名对象
           */
      }
}