JAVA知识点(类、方法、构造器、权限、修饰符、数据类型等知识点)

注意事项:

同一个包中不能有一样的类名的类,不然编译会出现错误。

(二)单例类(Singleton)

1、把构造器用private隐藏。

2、用static创建一个自定义只允许创建一个对象实例的静态方法(这样即使还没创建对象,就可以由类调用进行检查是否已经存在实例了并进行判断)。

例如:

public class Singleton {
    private static Singleton instance;//使用类变量来缓存曾经创建的实例;
    //对构造器用private进行修饰;
    private Singleton(){}
    //提供一个静态方法,用于返回Singleton实例,所以它的返回对象类型就是Singleton;
    //该方法加入自定义控制,保证只产生一个对象;
    public static Singleton getInstabce(){
        if(instance==null) {
            instance = new Singleton();
        }
        return instance;
    }
    public static void main(String[] args) {
        //创建对象不同构造器;
        //只通过自定义方法创建对象实例;
        /*Singleton s1=new Singleton();
        Singleton s2=new Singleton();
        System.out.println("s1==s2:"+(s1==s2));*/   //这样创建出来输出false;
        //getInstance()被定义为静态方法,在程序加载字节码时不用创建实例,可以由类调用
        Singleton s1= Singleton.getInstabce();
        Singleton s2=Singleton.getInstabce();
        System.out.println("s1==s2:"+(s1==s2));//输出true;

(三)匿名内部类及Lambda表达式

1、匿名内部类(实现接口/继承父类):

看似直接定义一个接口的对象(实际接口是没有实例对象的),实际可以认为是在定义另一个实现该接口(父类)的一个类的实例,并对接口中的抽象方法等进行实现。

(1)不能是抽象类(里面的方法等必须是已实现的)

(2)不能定义构造器,因为没有匿名内部类的类名。

(3)可以定义初始化块。可以在初始化块完成构造器里面需要完成的任务。

2、Lambda表达式(参考:http://www.cnblogs.com/CarpenterLee/p/6507161.html):

Lambda表达式中形参列表是对应的接口中抽象方法的形参。

其中一个main函数中可以存在对应多个函数接口的Lambda表达式:

//存在一个或者多个函数接口时的在main()函数的Lambda表达式示例
interface Converter{
    Integer converter(String from);
}
////////////////////////////////
interface Mytest1{
    String test(String a,int b,int c);
}
public class Myinterface {
    public static void main(String []args){

        //Converter converter1=(from)->Integer.valueOf(from);
        //Converter converter1=Integer::valueOf;
        //Converter converter1=from->"you".indexOf(from);
        Converter converter1="you"::indexOf;
        Integer val=converter1.converter("u");
        System.out.println(val);
        ///////////////////////////////////
      //对应的参数可以要么全部加上参数类型,要么全部不加;
        Mytest mt=(String a,int b,int c)->a.substring(b,c);
Mytest1 mt=( a, b, c)->a.substring(b,c); //Mytest mt=String::substring; String str=mt.test("jana i love you",2,9); System.out.println(str); }}

其中匿名内部类及Lambda表达式的区别:

1、匿名内部类可为任意接口创建实例——不管接口含有多少个抽象方法。

Lambda表达式只能为函数式接口创建实例(里面只含有唯一一个抽象方法,但是可以有多个默认方法).

2、匿名内部类可以为普通类、抽象类创建实例,但是,Lambda·表达式只能为函数式接口创建。

3、匿名内部类实现的抽象方法允许调用接口中定义的默认方法,但是Lambda表达式不允许这样调用。

二、权限与修饰符(public、protect、private、final)

1、一般被定义为私有的属性(private)需要设置其setter(),getter()方法,方便封装之后被使用。

2、"构造器没有返回值为什么不可以用void声明?"  

答:实际类的构造器是有返回值的,当使用new关键字调用构造器时,构造器返回该类的实例,可把该实例当做返回值。必须注意,不要在构造器中显示使用return来返回当前类的对象,因为构造器的返回值是隐式的。

3、final修饰的成员变量必须由程序员显式的指定初始值(系统不会对final成员进行隐式初始化),当该变量被赋予初始值时,就不能再被重新赋值。普通方法不能为final修饰的变量赋值。

(1)final修饰基本类型变量

①final修饰类变量(final static ):该类变量可以在声明的时候指定类初始化时分配默认值(不推荐,最好显示初始化)静态语句块中初始化(不能在普通初始化块初始化,因为类变量在类初始阶段就已经被初始化了,之后普通初始化块就不能再对其赋值)。只在这二者之一初始化。

②final修饰的成员变量(实例变量)可以在定义时初始化,普通(必须为非静态)初始化块初始化(实例变量不能在静态初始化块制定初始值,因为静态初始化块是静态成员,不可访问实例变量),构造器中初始化,只在这三者之一。普通方法不能为final修饰的成员变量赋值。

例如:

public class FinalVariableTest {
    //定义成员变量指定默认值,合法;
    final int a=6;
    final String str;//可在构造器、普通初始化块初始化;
    final int c;//可在构造器、普通初始化块初始化;
    final static double d;//静态初始化块;
    // final char ch; 若哪儿都没有初始化是不合法的;
    //普通初始化块
    {
        str="Hello";
        //不能重新为a赋值;
        //a=9;
    }
//静态初始化块
    static {
    d=5.6;//为类变量初始赋值;
}
public  FinalVariableTest(){
    c=5;
}
public void changeFinal(){
    //普通方法不能为final修饰的变量赋值;
    //d=2;
    //ch='a';
}
public static void main(String[] args){
    FinalVariableTest ft=new FinalVariableTest();
    System.out.println(ft.a);
    System.out.println(ft.c);
    System.out.println(ft.d);
}
}//输出为 6 5 5.6

(2)final修饰引用类型变量:只保证引用类型变量所引用的地址不改变,即一直引用同一个对象,但这个对象内部内容可以改变。

三、继承

1、

四、数据类型

1、Java中有5种成员:初始化块,成员变量,方法,构造器,内部类(包括接口、枚举)。其中,创建Java对象时,系统总是隐式先调用该类的定义的初始化块,根据初始化块所在位置从上到下执行,在构造器之前执行。因为它没有名字,表示,所以无法通过类、对象来调用初始化块,初始化块只能用static修饰。

2、基本类型与引用类型的区别:

(1)基本类型:它的值就是一个数字,一个字符或一个布尔值。

(2)引用类型:是一个对象类型,值是什么呢?它的值是指向内存空间的引用,就是地址,所指向的内存中保存着变量所表示的一个值或一组值除了在函数传值的时候是"引用传递",在任何用"="向对象变量赋值的时候都是"引用传递"。

例如:

int  a;  
 a=250; //声明变量a的同时,系统给a分配了空间。

引用类型就不是了,只给变量分配了引用空间,数据空间没有分配,因为谁都不知道数据是什么,整数,字符?我们看一个错误的例子:

MyDate today;

today.day = 4; //发生错误,因为today对象的数据空间未分配。

那我们怎么给它赋值?引用类型变量在声明后必须通过实例化开辟数据空间,才能对变量所指向的对象进行访问。举个例子:

MyDate today;            //将变量分配一个保存引用的空间

today = new MyDate();     //这句话是2步,首先执行new MyDate(),给today变量开辟数据空间,然后再执行赋值操作

//引用变量赋值

MyDate a,b;                    //在内存开辟两个引用空间

a  =  new MyDate();     //开辟MyDate对象的数据空间,并把该空间的首地址赋给a

b  =  a;                               //将a存储空间中的地址写到b的存储空间中

如下图示


3、包装类

基本类型:byte、short、int、long、char、float、double、boolean

包装类:Byte、Short、Integer、Long、Character、Float、Double、Boolean

注意:虽然包装类型的变量是引用数据类型,但包装类的实例可以与数值类型进行比较,直接去除包装示例所包装的数值进行比较,例如:

Integer a=new Integer(6);
 //输出true ;
System.out.println("6的包装类实例是否大于5.0"+(a>5.0));

但是和下例相对比:

原因:这与Java的Integer的设计有关,系统把一个-128~127之间的整数自动装箱成Integer实例,并放入一个名为cache的数组中缓存起来。所以只要是实例-128~127之间的整数就会在同一个空间中,地址相等,超出范围就重新创建shil

//输出true
Integer a=2;//通过自动装箱,允许把基本类型赋值给包装类实例;
Integer c=2;
System.out.println("比较2个包装类实例是否相等"+(a==c));
//输出false
Integer d=128;
Integer e=128;
System.out.println("比较2个包装类实例是否相等"+(d==e));

但是,因为包装类的实例实际上是引用类型,只有两个包装类引用同一个对象时才会返回ture。例如:

//输出false
System.out.println("比较2个包装类实例是否相等"+(new Integer(2)==new Integer(2)));

同下例,因为利用了关键字new创建了不同的内存空间:

//输出false
Integer a=new Integer (2);
Integer c=new Integer (2);
System.out.println("比较2个包装类实例是否相等"+(a==c));
4、  String(final)

Example:

String s1 = "abc";

String s2 = "abc";

System.out.print(s1==s2);

运行结果是:true

因为,String s = "abc"这种形式可以看做我们声明了一个值为”abc”的字符串对象引用变量,由于String类是final的,所以事实上,可以看做是声明了一个字符串引用常量, 存放在常量池中(栈中)。如果是使用关键字new这种形式声明出的,则是在程序运行期被动态创建,存放在中。

String s = “abc”的工作过程可以分为以下几个步骤:

 (1)定义了一个名为"s"的String类型的引用。

 (2)检查在常量池中是否存在值为"abc"的字符串对象;

 (3)如果不存在,则在常量池(字符串池)创建存储进一个值为"abc"的字符串对象。如果已经存在,则跳过这一步工作。

 (4)将对象引用s指向字符串池当中的”abc“对象。

String s = new String(”abc“)的步骤则为:

 (1)定义了一个名为"s"的String类型的引用。

 (2)检查在常量池中是否存在值为"abc"的字符串对象;

 (3)如果不存在,则在常量池(字符串池)存储进一个值为"abc"的字符串对象。如果已经存在,则跳过这一步工作。

 (4)在堆中创建存储一个”abc“字符串对象。

 (5)将对象引用指向堆中的对象。

这也就是为什么有道面试题:String s = new String(“xyz”);产生几个对象?的答案是:一个或两个的原因。因为如果常量池中原来没有”xyz”,就是两个。

如果需要把基本类型变量→字符串

(1)可将基本类型变量与“”进行连接。例如:

//intstr的值为"5";
String intstr=5+""

(2)利用valueOf()方法把基本类型转换成字符串,例如:

//把float变量转换成String变量;
String ftstr =String.valueOf(2.34764);
System.out.println(ftstr);
而字符串转成基本类型则可使用包装类提供的静态方法parseXxx(String s)。

eg: parseInt(),parseFloat().....

5、很多语言都不允许通过独享访问类变量,对象只能访问实例变量,类变量必须通过类来访问。(其实主要是实例变量和类变量两大类

(1)类变量:

①也叫静态变量,在类中以static关键字声明,但必须在方法构造方法和语句块之外。

静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和static类型的变量,很少单独使用static声明变量。

③默认值和实例变量相似。数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null。

④可通过实例对象访问,也可通过类来访问,即使某个实例是null,null也可以访问它所属的类成员.

(2)实例变量:

①“实例变量”,在实体类或数据类中被称为“属性”或“字段”,声明在一个类中,但在方法、构造方法和语句块之外。实例变量在对象创建的时候创建,在对象被销毁的时候销毁。

②实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息

③实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见。

④实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定。

(3)成员变量:

①类中的属性,独立于方法之外,与实例变量重叠,有些类变量也是成员变量。

(4)局部变量:

类的方法、构造器中的变量,是被局部使用的。

例1:

public class Variable{

    static int allClicks=0;//类变量

    String str="hello world";//实例变量、成员变量

    public void method(){

        int i =0;//局部变量

        int a;//局部变量

    }

}

例2:

public class StaticTest {

    private static int staticInt = 2;
    private int random = 2;

    public StaticTest() {
        staticInt++;
        random++;
        System.out.println("staticInt = "+staticInt+"  random = "+random);
    }

    public static void main(String[] args) {
        StaticTest test = new StaticTest();
        StaticTest test2 = new StaticTest();
    }
}
//运行结果:
//staticInt = 3  random = 3
//staticInt = 4  random = 3//每次创建对象重新调用全新的构造器,重新加1
例3:

public class Temp {
    static int t; //类变量  
    public static void main(String args[]){
        System.out.println(t; //打印类变量  
        int t = 1; //局部变量  
        System.out.println(t); //打印局部变量  
        Temp a = new Temp(); //创建实例  
        System.out.println(a.t; //通过实例访问实例变量  
    }
}      //结果为:0 1 0

四、集合

1、Stream

参考链接:

http://www.cnblogs.com/CarpenterLee/p/6545321.html

http://www.cnblogs.com/CarpenterLee/p/6550212.html


五、IO

1、问题:这个对象不是文件吗?为什么还要调用其他方法再次创建文件。

答:File类实例化,比如 File f=new File("E:/file_ceshi/02.rmvb");只是指向了这个02.rmvb文件,如果不创建02.rmvb,此文件是不存在的。因为代码只是声明不是运行,否则会出错。

















阅读更多
个人分类: java
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭