【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
{
    public void aa(T t)
    {   
    }
    
    public void bb(T t1,T t2)
    {    
    }
    
//    类上声明的泛型只对非静态成员有效
    public static  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;
    }
     }




你可能感兴趣的:(java)