【java】一些容易忽略的问题

1. 静态方法中不能调用非静态的成员或成员方法 ：

    不能引用非静态成员变量大家都很清楚：

    public class A
{
    int a;
    public static void main(String[] args)
    {
      a = 2;//错误!!a非静态
    }
}

但是大家往往忽略以下的情况：

package cn.edu.chd.test;
public class B
{
    public static void main(String[] args)
    {
        new C();//错误,该类是动态类
        new B().new C();//正确  
        new D();//正确，该类是静态类
    }
    public void func()
    {
        new C();//正确
        new D();//正确
    }
    class C
    {
    }
    static class D
    {
        
    }
}

C类相当于B类的成员变量，故不能在静态方法中new出实例（记住： 类中的静态方法不能直接调用动态方法）。

否则会提示错误：

No enclosing instance of type B is accessible. Must qualify the allocation with an enclosing instance of type B (e.g. x.new A() where x is an  instance of B).

2.protected修饰的构造器在包内部可以被new实例，在其他包非子类中不能被new实例。其他包子类可以访问(包括匿名类)：

domain包：

package cn.edu.chd.domain;
public class A
{
    protected A(){
        System.out.println("A constructor");
    }
}

test包：

package cn.edu.chd.test;
import cn.edu.chd.domain.A;
public class B
{
    public static void main(String[] args)
    {
    }
    public void func()
    {
        new A();//错误!!!The constructor A() is not visible
        new C();//正确，A的子类可以调A类的protected构造器
      new A(){};//正确，其实这个匿名内部类就相当于new了A的子类  
    }
    class C extends A
    {//C类的无参构造器其实调用了super.A()
    }
}

3.类前面的修饰词只有三种（public/abstract/final）,当然内部类除外。

4.访问权限问题：

类中某成员(方法或属性,method or field)的访问权限:

1、package(或称为friendly，但不用写出，friendly也不是关键字)权限，在同一包中的类和继承该类的子类可以访问；

2、public权限，任何类都可以访问；

3、private权限，该类内部的成员(方法、属性、内部类)可以访问，连该类的实例对象都不可以访问；

4、protected权限，继承访问权限，包内其余类和继承该类的子类可以访问，跟friendly权限差不多。

类中构造函数的访问权限:

1、public 很简单，不说了

2、protected 构造函数可以被继承该类的子类调用，但不能在包外或子类以外的地方被调用用来产生实例

3、private 该类无法被继承

内部类的访问权限:

1、public 任何地方均可访问

2、protected 在同一个包内均可访问，不同的包的子类可以访问

3、friendly(即默认权限) 同一个包内才可以访问

4、private 只有该内部类的外部类本身可以访问

类的访问权限:

1、public 任何地方均可访问

2、friendly 即默认权限，又称为package权限，在同一个包内可访问

5.抽象类是以abstract修饰的类，这个类里面可以有抽象的方法也可以没有！！

（1）.抽象类不一定有抽象方法，但是有抽象方法的类一定是抽象类。

（2）.抽象类不能被实例化！

package cn.edu.chd.demo;
public abstract class Demo
{
//    public abstract void func();//没有抽象方法也叫抽象类，比如HttpServlet类
    public void func1()
    {
        
    } 
}

6.类上声明的泛型只对非静态成员有效

package cn.edu.chd.basic;
public class Demo<T>
{
    public void aa(T t)
    {   
    }
    
    public void bb(T t1,T t2)
    {    
    }
    
//    类上声明的泛型只对非静态成员有效
    public static <T> void cc(T t)
    {
    }
}

7. finally块中代码不执行的一种情况

package  demo;
/**
 *  @author   Rowand   jj
 *这种情况下finally块中代码不执行
 */
public   class  TryDemo
{
     public   static   void  main(String[] args)
    {
         try
        {
            System. out .println( "aaaa" );
            System. exit (1);
        }  catch  (Exception e)
        {
             //  TODO : handle exception
        }
         finally
        {
            System. out .println( "ha" );
        }
    }
}

8. final 修饰的变量，其引用的对象不可以改变，但是我们可以改变对象的内容。

public   class  Deemo
{
     public   static   void  main(String[] args)
    {
         final   Person  p =  new   Person ( "zhangsan" ,11);
        p.setAge(12);//可以
        System. out .println(p.getAge()); 
//        p = new Person(" lisi ",22); //错误
    }
}
class   Person
{
     int   age ;
    String  name ;
    
     public  Person(String name, int  age)
    {
         this . name  = name;
         this . age  = age;
    }
     public   int  getAge()
    {
         return   age ;
    }
     public   void  setAge( int  age)
    {
         this . age  = age;
    }
     public  String getName()
    {
         return   name ;
    }
     public   void  setName(String name)
    {
         this . name  = name;
    }
     }