java方法参数类型以及返回值类型问题研究

1.方法参数类型以及返回值类型问题研究
1.01方法参数类型
1.类名作为形式参数
当你以后看到一个方法的形参要一个 类 类型，你就传递一个该类的对象。

public static void main(String[] args) {
Student student = new Student();
set(student, 60);
student.show(new Student(), 80);//如果新new的new Student()没有进行实例化，就不会执行。
System.out.println(student.num); //运行结果：60
}

public static void set(Student student, int num)
{
    student.num = num;
}

}

class Student {
int num = 20;

public void show(Student student, int num) {
    student.num = num;
    //this 代表那个调用者
    //this.num=90;
}

}

2.抽象类名作为形式参数
当你以后看到一个方法的形参要一个抽象类 类型，你就传递一个该抽象类的子类对象。

public static void main(String[] args) {
//当你以后看到一个方法的形参要一个抽象类 类型，你就传递一个该类的 子类对象。
Cat cat = new Cat();
set(cat, 100);//传参
cat.show(500);
System.out.println(cat.num);//
}

public static void set(Animal animal, int num) {//方法的形参要一个抽象类
    animal.num = num;
    // ((Cat) animal).num=num;
}

}
abstract class Animal {
int num = 50;

public abstract void show(int num);

}
class Cat extends Animal {
int num = 60;

@Override
public void show(int num) {
    super.num = num;
    this.num=num;
}

}

3.接口名作为形式参数
你以后看到一个方法的形参要一个接口 类型 ，你就传递一个该接口的子类对象。

public class Mytest {
public static void main(String[] args) {
//当你以后看到一个方法的形参，要一个接口 类型，你就传递一个接口的子类对象。
MyClass myClass = new MyClass();
set(myClass,400);
System.out.println(myClass.num); //400
System.out.println(MyInterface.num); //2000
}

public static void set(MyInterface myInterface,int num){
    myInterface.show(num);
}

}

interface MyInterface {
public static final int num=2000;//接口默认常量
void show(int num);
}

class MyClass implements MyInterface{
int num=2;
@Override
public void show(int num) {
this.num=num;
}
}

1.02返回值类型
1.类名作为返回值类型
当你以后看到一个方法的返回值类型，是一个类 类型，你就返回一个该类的对象。

public static void main(String[] args) {
Student stu = getStudent();//返回一个该类的对象。
Student stu1 = stu.getStu();
System.out.println(stu==stu1);//ture
System.out.println(stu1.num);//30
System.out.println(stu.num);//30
}
public static Student getStudent() {
Student student = new Student();
student.num = 20;
return new Student();
}
}

class Student {
int num = 30;
public Student getStu() {
return this;
}
}

2.抽象类名作为返回值类型
当你以后看到一个方法的返回值类型是一个抽象类 类型，你就返回一个该抽象类的子类对象。

public static void main(String[] args) {
Animal an = getAnimal();
an.num = 600;
System.out.println(an.num);//600
//向下转型
Animal animal=new Dog();
Dog dog= (Dog) an;
System.out.println(dog.num);//70
//向下转型
//Dog dog = (Dog) getAnimal();
}

//当你以后看到一个方法的返回值类型，要一个抽象类 类型，你要返回一个该类的子类对象。
public static Animal getAnimal() {
    Dog dog = new Dog();
    dog.num=70;
    return dog;
}

}

abstract class Animal {
int num=20;
}

class Dog extends Animal {
int num=100;
}

3.接口名作为返回值类型
当你以后看到一个方法的返回值类型是一个接口 类型，你就返回一个该接口的子类对象。

public class Mytest {
public static void main(String[] args) {
Plusx a=getPlusx();
System.out.println(Plusx.num);//常量可以直接用接口名调用
System.out.println(a.num);
}
public static Plusx getPlusx(){
return new X();
}
}
interface Plusx{
int num=333;
}
class X implements Plusx{
int num=777;
}

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

Student stu=  getStu();
Student stu2=stu.getStudent();
int add = stu2.add(20, 30);
System.out.println(add);
 //链式编程的语法风格:当你调用完一个方法后，他返回一个对象，那你就可以紧接着打点，再去调用这个对象所属类中的方法。
//int add = getStu().getStudent().add(60, 30);
System.out.println(add);

1
2
3
4
5
6
7
5.package关键字的概述及作用
1.包的概述: 就是文件夹
2:包的作用: 用来解决同一个路径下不能存在同名文件的问题(分类管理)
3:包的划分:
按照功能
按照模块

6.包的定义及注意事项
1.定义包的格式
package 包名;
多级包用.分开即可
2.定义包的注意事项
A:package语句必须是程序的第一条可执行的代码
B:package语句在一个java文件中只能有一个
C:如果没有package，默认表示无包名

7.不同包下类之间的访问
定义两个类：Demo,Test。
Demo
求和方法(sum)
Test
测试方法(main)

8.import关键字的概述和使用
导包的概述
不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能
B:导包格式
import 包名;
注意：
这种方式导入是到类的名称。
虽然可以最后写*，但是不建议。

package,import,class有没有顺序关系(面试题):

有顺序呢，package是第一句，import在中间，class在最后。import和class可以多句，但package只有一句。

2.权限修饰符
2.01四种权限修饰符的测试
四种权限修饰符: private(私有的) , 默认 , protected(受保护的) , public(公共的)
结论
本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y

2.02类及其组成所使用的常见修饰符
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
public abstract
public final

3.内部类
3.01内部类概述和访问特点
1.内部类概述:

​ 把类定义在其他类的内部，这个类就被称为内部类。
​ 举例：在类A中定义了一个类B，类B就是内部类。

class B {
//成员内部类
class A {
}
public void show() {
//局部内部类
class C {
}
}
}

2.内部类访问特点
a:内部类可以直接访问外部类的成员，包括私有。
b:外部类要访问内部类的成员，必须创建对象。

public class MyTest {
public static void main(String[] args) {
Outer.Inner inner=new Outer().new Inner();
inner.neiShow();
}
}
class Outer {
int num = 10;
private int a = 20;

class Inner {
    int nei = 200;
    public void neiShow() {
        System.out.println("内部类的成员方法");
        System.out.println(num);
        System.out.println(a);
        System.out.println(nei);
        waiShow();
        waiTest();
    }
    public void neiTest() {
        System.out.println("内部类的成员test方法");
    }
}
public void waiShow() {
    System.out.println("外部类的成员方法");
}
private void waiTest() {
    System.out.println("外部类私有的成员方法");
}
public void hehe(){
    Inner inner = new Inner();//重点
    System.out.println(inner.nei);
    inner.neiTest();
}

}

3.02内部类分类及成员内部类的直接使用
1.按照内部类位置分类：
成员位置:在成员位置定义的类，被称为成员内部类。(类中方法外)
局部位置:在局部位置定义的类，被称为局部内部类。（方法中）

2.成员内部类：
如何在测试类中直接访问内部类的成员。
格式: 外部类名.内部类名 对象名 = 外部类对象.内部类对象;

​ Wai.Nei nei=new Wai().new Nei();

1.内部类，可以使用private来修饰

class Wai {

private class Nei {
    public void neiShow() {
        System.out.println("内部类的方法");
    }
}

私有的内部类，外界无法创建其对象。Wai.Nei nei=new Wai().new Nei();

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

}

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

public static void hehe(){
}

}

3.03成员内部类的常见修饰符及应用
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.neiShow();
}


private void test(){
    System.out.println("外部类的私有方法");
}

public void hehe(){
    //Nei nei=new Nei();
    //Inner inner = new Inner();
    show();
}

}

3.04局部内部类访问局部变量的问题
1.可以直接访问外部类的成员

2.可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
3:局部内部类访问外部类局部变量（方法内的形参）必须用final修饰
为什么呢?
因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。
为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。
JDK1.8之后，final会默认加上，你不用手动去加，但是你要知道

4.匿名内部类
4.01匿名内部类的格式和理解
1.匿名内部类:就是局部内部类的简化写法。
B:前提：存在一个类或者接口;这里的类可以是具体类也可以是抽象类。
C:格式：
new 类名或者接口名(){
重写方法;
} ;
D:本质是什么呢?
是一个继承了该类或者实现了该接口的子类匿名对象。

public class MyTest {
public static void main(String[] args) {
//匿名内部类：他是局部内部类的一种简写形式。
//语法格式：new 接口名/类名(){重写方法}
//匿名内部类的本质：匿名内部类本质上是一个对象，是谁的对象，是实现了该接口或者继承了该抽象类的子类对象。
// A a = new A();
new MyClass(){
@Override
public void show() {
System.out.println(“重写了父类的抽象方法”);
}
}.show();

}
}

abstract class MyClass {
public abstract void show();
}

class A extends MyClass{

@Override
public void show() {

}

}

public class MyTest2 {
public static void main(String[] args) {
/* B b = new B();
b.show();*/
//匿名内部类：本质上是一个对象，是谁的对象呢？是实现了该接口或继承了该抽象类的子类对。
new MyInterface(){
@Override
public void show() {
System.out.println(“aaaa”);
}
};

    new MyInterface() {
        @Override
        public void show() {
            System.out.println("bbb");
        }
    }.show();

    new MyInterface() {
        @Override
        public void show() {
            System.out.println("ccc");
        }
    }.show();

}

}

interface MyInterface{
void show();
}

/*
class B implements MyInterface{

@Override
public void show() {
    System.out.println("abc");
}

}
*/

4.02匿名内部类在开发中的应用
1.匿名内部类经常可以作为参数来传递。比较方便

2.匿名内部类，作为返回值来返回

//匿名内部类，作为返回值来返回
public static Myinterface getInstance() {
return new Myinterface() {
@Override
public void aa() {
System.out.println(“aaaaaaaaaaaaaaaaa”);
}
};
}

//匿名内部类，作为返回值来返回
public static Animal getInstance2() {
    Animal an = new Animal() {
        @Override
        public void sleep() {
            System.out.println("天天睡觉");
        }
    };
    return an;
}

}

interface Myinterface {
void aa();
}

abstract class Animal {
public abstract void sleep();
}

3.在外界可以采用内部类的方式，创建出内部接口的子类对象。

public class MyTest {
public static void main(String[] args) {
//在外界可以采用内部类的方式，创建出内部接口的子类对象。
AA.BB b = new AA.BB() {
@Override
public void bb() {
System.out.println(“bbbbbbbbbbbbbbb”);
}
};

}

}

//在一个类里面可以定义一个接口。
class AA {
//内部接口 内部接口 可以私有，私有后外界就无法创建其子类对象。
interface BB {
void bb();
}
}

匿名内部类具有一系列的限制：

1.不能具有static成员域和成员函数和类。

2.不能具有static final修饰的引用类型。

3.不能具有s自定义的构造函数

4.不能具有静态代码块。

5.匿名内部类不能具有类修饰符。

4.03匿名内部类中this关键字
interface Inter {
public static final int a = 23 ;
}

public class Test {

public static void main(String[] args) {
	new Inter() {
		public void show() {
			//this 代表匿名内部类
			System.out.println(this.a);//23

		}
	}.show();
}