成员内部类就是定义在一个类的内部,其实是相当于成员变量的位置。 下面这两种其实都可以被称为成员内部类的,只不过一般static修饰的这种我们一般也可以称之为静态内部类。我们先来研究成员内部类(也可以称之为非静态内部类)怎么定义的话合理即可,明白意思就可以了。
class Outer{
class Inner{
//非静态成员内部类
}
static class Inner_1
{
//静态成员内部类
}
public static void main(String args[]){
/*.........*/
}
}
来看一个简单的例子,也可以自己去测试访问和定义的修饰符
package java_practice;
public class OuterandInner {
private byte b = 1;
static String country = "china";
String home = "shanxi";
public void systemdemo() {
// System.out.println(Inner.this.name);//这样是不可以的。
}
public String author = "jgdabc";
class Inner {
String name = "jgdabc";
// static String name_1 = "";//这样不允许
private String password = ".....";
public void systemdemo() {
System.out.println(OuterandInner.this.author);
System.out.println(author);
System.out.println(Inner_1.age);
// System.out.println(name_1);//这样访问不了
System.out.println(b);//非静态内部类可以访问到外部私有化成员
}
}
static class Inner_1 {
public static void showdemo() {
//.....
// System.out.println(Inner.name);//这样不可以
// Inner inner = new Inner();//不可以这样去new,因为没有main方法
// System.out.println(b);//静态局部内部类是不能访问到外部类私有成员的
System.out.println(country);
}
String name_1 = "jgdabc_1";
private String password_1 = "lmddkskk";
static int age = 19;
public void systemdemo() {
// System.out.println(OuterandInner.this.author);//这样是不可以的
System.out.println(OuterandInner.country);//这样可以访问,并且直接通过类名进行访问
}
}
public static void main(String args[]) {
System.out.println("......");
OuterandInner outerandInner = new OuterandInner();
// System.out.println(outerandInner.name);//访问不到内部类成员
// System.out.println(name);//
System.out.println(outerandInner.author);//自己的成员变量直接可以通过实例访问
Inner inner = outerandInner.new Inner();
System.out.println(inner.name + inner.password);
// Inner inner1 = new Inner();//动态的外部类不能被直接在外部类new()
// System.out.println(name_1);//不能访问
OuterandInner outerandInner1 = new OuterandInner();
// System.out.println(outerandInner1.name);//不能访问
Inner_1 inner_1 = new Inner_1();//静态的可以直接进行new实例化
System.out.println(inner_1.name_1 + inner_1.password_1);
System.out.println(Inner_1.age);//直接通过类名来调用静态成员内部类的静态成员
// System.out.println(Inner_1.name);//这样是不可以的
Inner_1.showdemo();//也可以直接通过类名调用静态成员内部类的静态方法。
}
}
上面代码测试了一些常规的方法。下面简单说明几点
1:首先非静态成员内部类里面是不可以定义静态的属性的,否则编译不会通过。
2:非静态成员内部类成员不能被外部直接访问,不能只通过实例外部类访问内部类成员
3:访问非静态成员内部类成员属性可以通过外部类实例的对象.new 内部类, 示例如下
// An highlighted block
Inner inner = outerandInner.new Inner();
4:非静态成员内部类可以访问到外部类的属性 然后可以通过inner调用非静态成员内部类属性。
5:非静态成员内部类可以访问到外部私有化属性。
6:外部类也是不能直接访问静态局部成员内部类成员的,这个特点同属于对内部类访问的特点。 7:静态成员内部类可以直接自己进行实例化,而无需通过外部类实例进行调用实例化。 8:静态成员内部类不可以访问到外部类的私有化成员
9:静态成员内部类可以直接访问到外部类的静态成员
10:静态成员内部类不能直接访问外部类非静态成员
局部内部类是一个在方法中定义的内部类 既然是局部内部类,定义在方法体中,那么只在当前方法体当中有效。无论是静态的还是非静态的,都是一样的法则。
特别注意它的作用范围,就是是去实例化它所在的类,只要不再方法体内都是无效。
public void systemdemo() {
class demo_test {
int age = 19;
public int id = 123;
// static String name= "hello";//不可以有静态修饰的成员
// static void system_demo()
// {
// //不可以这样用
// }
private String password = "";
public void show_demo() {
System.out.println("我是局部内部类");
System.out.println(home+b+password);//可以访问到外部类的成员,即便是私有的。
}
}
demo_test demo_test = new demo_test();
demo_test.show_demo();
// System.out.println(Inner.this.name);//这样是不可以的。
}
// new demo_test();//这样是不可以的
没有静态局部内部类一说
匿名内部类也是经常会用到,就比如在重写一个比较器的时候可以通过类名内部类实现。另外,我们也可以自己定义一些具备功能的接口去实现匿名内部类。 简单举例说明一下
package java_practice;
class demo{
public void demo()
{
System.out.println("demo");
}
}
public class AnonymousInner {
public static void main(String args[])
{
new demo(){
public void demo()
{
System.out.println("demo重写");
}
}.demo();
}
}
下面这个例子实现了内名进行重写比较器
package java_practice;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo01 {
public static void main(String args[])
{
TreeMap tm = new TreeMap<String,String>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
//。。。
}
});
tm.put("Hello","world");
String set = String.valueOf(tm.keySet());
System.out.println(set);
System.out.println(set.getClass());
System.out.println(set);
}
}
package java_practice;
public class Student implements Comparable<Student>{
private int age;
private String name;
public Student(int age, String name) {
this.age = age;
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
@Override
public int compareTo(Student s) {
int num = this.age - s.age;
int num2 = num == 0 ? this.name.compareTo(s.name) : num;
return num2;
}
}
package java_practice;
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSetDemo1 {
public static void main(String args[]) {
TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s1.getAge() - s2.getAge();
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
return num2;
}
});
Student s1 = new Student(29, "西施");
Student s2 = new Student(28, "王昭君");
Student s3 = new Student(30, "貂蝉");
Student s4 = new Student(33, "杨玉环");
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
for (Student s : ts) {
System.out.println(s.getName() + "" + s.getAge());
}
}
}
匿名内部类实现接口
先给一个不适用匿名内部类实现的例子
package java_practice;
interface Demo_{
void demo_d();
}
class Demo_im implements Demo_
{
@Override
public void demo_d() {
System.out.println("实现demo_");
}
}
public class Demo_de {
public static void main(String args[])
{
Demo_im demo_im = new Demo_im();
demo_im.demo_d();
}
}
package java_practice;
interface Demo_{
void demo_d();
}
public class Demo_de {
public static void main(String args[])
{
Demo_ demo= new Demo_(){
@Override
public void demo_d() {
System.out.println("匿名实现接口");
}
};
demo.demo_d();
}
}
我就疑惑为什么mian方法非要是静态的? 我的理解比较浅显。因为这样的设计一定经过很好的预先思考的。对java的底层理解不是很深入。所以自己去参考了一些说法。
首先我们自己从程序执行上面去理解。我们的main方法是在类中,在类中的方法的一个特点就是如果如果不用static修饰,那就必须用实例化才可以访问,但是main是作为程序的如果啊!我们如果不进行直接访问的话,就得自己去实例化main,这样就比较复杂了。所以用static修饰得话,对我们得使用带来了一定得不变。这样其实这样修饰类成为了一种约定。
static修饰方法得特点再说明一下。
也就是说,static 修饰的方法陈为静态方法,静态方法是不依赖类的实列的,不需要通过类的实例去调用。main方法的调用是通过类的加载,链接,以及初始化,main没有被实例化过,所以需要调用的只能是通过声明为静态,然后进行调用。
这个就比较简单了。我们的java程序需要靠java虚拟机来调用,我们的这种执行调用方式属于外部调用,如果没有public修饰,是无法实现调用的,程序也就无法执行。
还是从程序执行需要方面来看,如果没有void修饰是一定需要返回值的。返回值对main又有什么意义呢?我们程序从main函数进行输出就是为了输出程序执行的内容。没有必要去返回值,返回又给谁呢?这不是我们需要的。
对比c,c++,的话,我们就好奇,为什么c,c++就可以进行返回,int main(),执行机制不一样啊,c,c++在程序进入函数执行的是偶,会启动运行时库,然后初始化环境,启动入口函数,然后程序进行执行,执行完毕后,退回运行时库,退回操作系统,然后操作系统继续调度其它的程序。
==但是java就不一样了。我们的java是由jvm进行调度的,jvm调度main函数,jvm被设计为不接受任何返回值,所以也就不能进行返回。 自己的理解浅显,希望自己可以不断学习,获得更多更加深入的认识。
String[] args[]或者String args[] 这样都是没有问题的,这个字符串主要的作用就是运行main函数的输入参数,不然它也不会写在那里,我们给main传入参数,args这个数组就会进行接收。
具体是如何传入呢? 可以利用idea来进行很方便的传参,
主函数里面对参数进行遍历
但是其实不知道这样进行传参的具体意义所在。
自己的理解浅显,希望自己可以不断学习,获得更多更加深入的认识。 希望得到指点。