引言
返回值问题、返回值问题、权限修饰符以及内部类的相关概念,其中,内部类需要重点理解。
形式参数问题
数据类型:
基本类型:byte,short,int,long,float,double,char,boolean
引用类型:类,接口,数组
形式参数:
基本类型:要的是该基本类型的数据值。
引用类型:要的是该引用类型的对象。
A:数组 要的是该数据类型数组的对象。(地址值)
B:类 要的是该类或者其子类的对象。(地址值)
C:抽象类 要的是该抽象类的子类对象。(地址值)
D:接口 要的是该接口的实现类对象。(地址值)
举其中一个例子:
//数组 要的是该数据类型数组的对象。(地址值)
public class ArgsStu01 {
public static void main(String[] args) {
int[] arr={1,5,3,2,6};
printArr(arr);
}
public static void printArr(int[] arr){
for(int i=0;iout.print(arr[i]+" ");
}
}
}
再写一个抽象类的相关例子:
public class ArgsStu02 {
public static void main(String[] args) {
PersonStu ps=new PersonStu();
Person s=new Student();
ps.function(s);
}
}
abstract class Person{
public abstract void eat();
}
class Student extends Person{
@Override
public void eat() {
System.out.println("大多数学生喜欢吃米饭");
}
}
class PersonStu{
public void function(Person s){
s.eat();
}
}
返回值问题
返回值:
基本类型:byte,short,int,long,float,double,char,boolean
引用类型:类,接口,数组
返回值之基本类型:
基本类型:返回的是该基本类型的数据值。
返回值之引用类型:
返回值是类名:其实返回的是该类对象或者其子类对象。(地址值)
返回值是抽象类名:要的是该抽象类的子类对象。(地址值)
返回值是接口名:要的是该接口的实现类对象。(地址值)
在这里,举一个返回值类型是接口名的简例:
interface Inter{
public abstract void jumpCat();
}
class Cat implements Inter{
@Override
public void jumpCat() {
System.out.println("猫会跳高");
}
}
class InterStu{
public Inter method(){
Inter c=new Cat();
return c;
}
}
public class ArgsStu03 {
public static void main(String[] args) {
InterStu is=new InterStu();
Inter c2=is.method();
c2.jumpCat();
}
}
权限修饰符
权限修饰符:在哪种情况下可以被访问到。
下面举一个在同一个类中的权限修饰符的访问特点:
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");
}
}
编译运行结果为:
public
private
默认修饰符
protected
常见的修饰:
类: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() {}
有关权限修饰符还有一个知识点需要注意,如下图:
注意:
四种权限修饰符,只能有一种存在。
常见的组合:
类:
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() {}
内部类
有关内部类的相关知识点是一个比较难理解的地方,特别是对于我这个初学者,因此,有关的概念必须清晰明了,相关代码也必须多多练习。
内部类:
把类A定义在类B的内部,类A就被称为内部类。
访问特点:
A:内部类可以直接访问外部类的成员,包括私有。
B:外部类要访问内部类的成员,必须创建对象。
例如下面代码所示:
//外部类
class Outer{
private int num=10;
//内部类
class Inner{
public void show(){
System.out.println(num);
}
}
//外部类的一个方法
public void method(){
Inner i=new Inner();
i.show();
}
}
public class InnerStu01 {
public static void main(String[] args) {
Outer o=new Outer();
o.method();
}
}
编译yun运行结果为:
10
内部类分类:
成员位置:成员内部类
局部位置:局部内部类
成员内部类:
外界如何创建对象
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
有关成员内部类创建对象举一个简单的例子:
//成员内部类
class Outer2{
class Inner{
public void show(){
System.out.println("这是一个成员内部类");
}
}
}
public class InnerStu02 {
public static void main(String[] args) {
//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer2.Inner oi=new Outer2().new Inner();
oi.show();
}
}
成员内部类的修饰:
A:private 为了我们访问数据的安全性
B:static 为了我们访问数据的方便性
局部内部类:
A:可以直接访问外部类的成员,包括私有
B:在成员方法中创建局部内部类的对象,调用局部内部类的功能
局部内部类访问局部变量必须加final修饰!!!
因为局部变量会随着方法的调用完毕而消失,这个时候,局部对象并没有立马从堆内存中消失,还要使用那个变量。为了让数据还能继续被使用,就用fianl修饰,这样,在堆内存里面存储的其实是一个常量值。
下面用一个例子说明:
// 局部内部类
class Outer3{
private int num=20;
public void show(){
final int num=30;
//内部类
class Inner3{
public void method(){
System.out.println(num);
}
}
Inner3 i=new Inner3();
i.method();
}
}
public class InnerStu03 {
public static void main(String[] args) {
Outer3 oi=new Outer3();
oi.show();
}
}
编译运行后输出:
30
匿名内部类
没有名字的局部内部类,就是内部类的简化写法
前提:
存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
格式:
new 类名或者接口名() {
重写方法;
};
本质:
是一个继承了类或者实现了接口的子类匿名对象。
举一个简单的例子:
//匿名内部类
abstract class Animal{
public abstract void eat();
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗都喜欢啃骨头");
}
}
class AnimalStu{
public void show(Animal a){
a.eat();
}
}
public class InnerStu04 {
public static void main(String[] args) {
AnimalStu as=new AnimalStu();
as.show(new Dog());
as.show(new Animal(){
public void eat() {
System.out.println("动物也有不吃肉的");
}
});
}
}
编译运行后结果为:
狗都喜欢啃骨头
动物也有不吃肉的