java学习（7）

java学习（7）

之前写完了java面向对象的部分内容，这篇来写关于参数类型，返回类型，修饰符，内部类这一块的内容！！！

1. 形式参数

之前也写过java里面的数据类型了，包括了基本数据类型和引用数据类型，基本数据类型就是那四类八种：

整型：byte,short,int,long   浮点型：float,double字符型：char布尔型：boolean，引用类型前面也写过了，包括：类,接口,数组，这里主要写的是参数传递的问题

在形参使用中，基本类型要的是该基本类型的数据值。

而引用类型要的是该引用类型的对象，其实就是地址值！！！。
1）数组 要的是该数据类型数组的对象。(地址值)
2）类   要的是该类或者其子类的对象。(地址值)
3）C:抽象类 要的是该抽象类的子类对象。(地址值)
4）D:接口 要的是该接口的实现类对象。(地址值)

代码示例：

//父类

class Fu2{
public void show(){
System.out.println("Fu的show方法");
}
}

//子类
class Zi2 extends Fu2{
public void show(){
System.out.println("Fu的show方法");
}
}
class Test{
public void method(Fu2 f){
f.show();
}
}
public class ArgsTest02 {
public static void main(String[] args) {
//创建Test对象
Test t = new Test();
//多态
Fu2 f = new Zi2();
System.out.println("多态");
t.method(f);
System.out.println("==========");
//子类对象
Zi2 z = new Zi2();
System.out.println("子类对象");
t.method(z);
System.out.println("==========");
//父类对象
Fu2 f2= new Fu2();
System.out.println("父类对象");
t.method(f2);
}
}

运行结果：

这里给出的是类作为形参的调用，参数可以使类或者子类的对象。其他数据类型调用相似，这里不做叙述了。

2. 返回值
返回值，同样也是关于基本数据类型和引用数据类型的问题。
返回值之基本类型：
基本类型：返回的是该基本类型的数据值。

基本数据类型的返回值使用最为简单，这里给出一个返回两个数差的代码示例：

public static void main(String[] args) {
//调用这个减法
int a = add(12,14);
System.out.println(a);
}
//创建一个方法，可以做两个数的减法，并返回两个数的差
private static int add(int i, int j) {
// TODO Auto-generated method stub
return i-j;
}

基本数据类型的返回值是最为简单的。

返回值之引用类型：
返回值是类名：其实返回的是该类对象或者其子类对象。(地址值)
返回值是抽象类名：要的是该抽象类的子类对象。(地址值)
返回值是接口名：要的是该接口的实现类对象。(地址值)
这里同样给出一个返回值是类名的代码示例：

//创建一个父类
class Person{
public void sleep(){
System.out.println("Person的sleep方法");
}
}
//创建一个子类
class Man extends Person{
public void method(){
System.out.println("Man的method方法");
}
}
class PersonTest{
public Person function(){
//返回值类型如果是一个类名：本质上需要的是这个类或者这个类的子类对象
Man m = new Man();
return m;
}
}
public class ReturnTest02 {
public static void main(String[] args) {
//调用PersonTest中的function方法
PersonTest pt = new PersonTest();
//可以用类的对象去接返回值
Person p = pt.function();
p.sleep();
System.out.println("========");
Man m = (Man)p;
m.method();
}
}
运行结果：

3. 权限修饰符

1）public（公共类型）可以在本类,同一个包下的类,不同包下的子类,不同包下的无关类被访问到；

2）protected（保护类型），默认可以在本类，同一个包下的类被访问到；

3）private（私有类型）只可以在本类中访问。

权限修饰public是最使用的，private在修饰成员变量的时候使用最多，其他两种类型不怎么使用。

4. 常见的内容修饰

这部分内容比较简单，不进行过多的描述。
4.1常见的修饰
类：public
成员变量：private
构造方法：public
成员方法：public

4.2 哪些东西可以修饰哪些东西（这里不包括内部类）

1）private可以修饰成员变量，构造方法，成员方法；

2）(默认)可以修饰类，成员变量，构造方法，成员方法；

3）protected可以修饰成员变量，构造方法，成员方法；

4）public可以修饰类，成员变量，构造方法，成员方法；

5）static可以修饰成员变量，成员方法；

6）final可以修饰类，成员变量，成员方法；

7）abstract可以修饰类，成员方法；
注意：四种权限修饰符，只能有一种存在。
常见的组合：
类： public class Animal {}
public final class Animal{}
public abstract class Animal {}
成员变量：
private String sex;
public final int x = 15;
public static int y = 25;
public static final int X = 35;
成员方法：
public void show1(){}
public abstract void show2();
public final void show3(){}
public static void show4() {}
public static final void show5() {}


5. 内部类

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

代码示例：

//定义内部类示例
class test1{
class test2{

}
}

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

示例代码：

//定义内部类示例
class test1{
private int num=13;
class test2{
private int num2 =14;
public void show(){
System.out.println(num);
}

}
private void show() {
test2 t2 =new test2();
System.out.println(t2.num2);
}

}

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

上面的代码已经说明了这个问题。

5.2.1成员内部类：
外界如何创建对象
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
5.2.2成员内部类的修饰：
A:private 为了我们访问数据的安全性
B:static  为了我们访问数据的方便性

代码示例：

//定义内部类示例
class test1{
private int num=13;
class test2{
private int num2 =14;
public void show(){
System.out.println("内部类的show方法");
System.out.println(num);
show2();
}

}
private void show2() {
test2 t2 =new test2();
System.out.println("外部类的show方法");
System.out.println(t2.num2);
}

}
public class InnerTest01 {


public static void main(String[] args) {
//创建内部类对象
test1.test2 tt = new test1().new test2();
tt.show();
}
}

运行结果：

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

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

这里给出了定义的局部内部类，并且进行局部内部类调用外部类的成员变量，成员方法，局部变量等等，在外部类的成员方法中创建局部内部类的对象，并调用局部内部类的成员方法等等，包括了上面说的绝大部分内容。

//局部内部类代码示例
class test1{
private int num1 =12;
public void show(){
System.out.println("外部类的成员方法");
}

//定义局部内部类,访问局部变量，外部类的成员变量，成员方法
public void show2(){
final int num2 = 14;
class testInner{
private int num3 = 45;
public void Innershow(){
System.out.println("局部内部类的show方法");
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
show();
}
}
//创建局部内部类的对象，调用局部内部类的功能
testInner ti = new testInner();
ti.Innershow();
}
}
public class InnerClassTest01 {


public static void main(String[] args) {
//创建外部类对象，进行调用
test1 t1 = new test1();
t1.show2();
}
}

运行结果：

5.4匿名内部类
没有名字的局部内部类,就是内部类的简化写法
前提：
存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
格式：
new 类名或者接口名() {
重写方法;
};
本质：
是一个继承了类或者实现了接口的子类匿名对象。

代码示例：

//匿名内部类代码示例，实现接口
interface Inter { 
public abstract void show(); 
}
class Outer{
//定义局部匿名类，返回接口实现子类匿名对象
public static Inter method(){
return new Inter(){
//重写方法
public void show() {
System.out.println("Hello， people!");
}
};
}
}
public class InnerClassTest01 {
public static void main(String[] args) {
//创建对象调用
Outer.method().show();
 }
}

运行结果：