JAVA总结篇四（类、方法、对象与变量）

类、方法、对象与变量

在这里记录的是部分常见的方面，至于其它方面就不多说了。

一、类（属性与方法的载体）

这里主要说的是具体类，抽象类，接口；

1.具体类：

具体类也是我们最常用到的类，主要有是由以下形式出现：

[访问权限修饰符]  [修饰符]  class   类名  {   类体  }；其中修饰符可有可无。

示列：public class test{

    public static void main（String[] args）{

        System.out.println("这是一个具体类的main方法");

    }

}

2.抽象类：

抽象类是在具体类的基础上加了一个为abstract的修饰符；因此抽象类大致具有以下特性：

1、不能实例化;

2、抽象类中既可以有普通方法，也可以有抽象方法；

3、继承了抽象类的类必须重写抽象类中的抽象方法；至于普通方法，可以不重写，如果重写了的话，调用的就是继承了抽象类的类重写了后的方法，反则调用的是抽象类中的方法。

示列：

package com.test;

public abstract class Abstract {// 抽象类
    public void test() {
        System.out.println("抽象类");
    }

    public void test0() {
        System.out.println("抽象类0");
    }

    abstract void test1();// 抽象方法

}

package com.test;

public class Classes extends Abstract {
    public void test0() {
        System.out.println("具体类");
    }

    @Override

    void test1() {

        System.out.println("抽象方法");

    }
 

}

package com.test;

public class Main {
    public static void main(String[] args) {
        Classes classes = new Classes();
        classes.test();
        classes.test0();
        classes.test1();
    }
}

最后打印出来的结果便是：抽象类
                                        具体类

                                        抽象方法

3.接口：

将具体类的class部分用interface替换了之后便是一个接口类

接口具有以下特性：

1、比抽象类更抽象，它的类体中只能有抽象类；

2、接口类体中的属性默认都是被public、static、final修饰的，而它的方法则默认都是被public、abstract修饰的；

3、接口只能被实现，不能被继承；由于JAVA中是单一继承多重实现，因此利用接口可以实现多重继承；

示列：

package com.test;

public interface Interface {
     String a="1";//相当于 public static final String a = "1";
     void test2();//相当于 public abstract void test();

}

package com.test;

public interface Interface0 {
    void test3();

}

package com.test;

public class Classes extends Abstract implements Interface , Interface0{
    public void test0(){
        System.out.println("具体类");
    }

    @Override
    void test1() {
        System.out.println("抽象方法");
    }

    @Override
    public void test2() {
        System.out.println("第一个接口实现类");
    }

    @Override
    public void test3() {
        System.out.println("第二个接口实现类");
        
    }
    

}

package com.test;

public class Main {
    public static void main(String[] args) {
        Classes classes = new Classes();
        classes.test2();
        classes.test3();
    }

}

最后打印出来的结果便是：第一个接口实现类
                                        第二个接口实现类

二、方法（即抽象出来的对象的行为）

方法的组成部分：[访问权限修饰符]+[修饰符] +返回类型+方法名（参数）+{方法体}

注：抽象方法的修饰符为 abstract 且无方法体；而一般的方法的返回类型默认都为空，即返回类型为void。

在这里主要说的则是方法重写、方法重载以及构造方法；

1.方法重写：

方法重写一般都是子类继承了父类后重写父类的方法；重写后的方法后，在子类中重写的方法将覆盖父类的方法；且重写的方法除了方法体可以不同外，其他部分都是相同的；

示列：

package com.test;

public class Classes{
    public void test4(){
        System.out.println("方法重写");
    }
    
}
package com.test;

public class Classes1 extends Classes{
    @Override
    public void test4() {
        System.out.println("子类方法重写");
    }

}

package com.test;

public class Main {
    public static void main(String[] args) {
        Classes1 clasese1 = new Classes1();
        clasese1.test4();
    }
}

最后打印出来的结果便是：子类方法重写

2.方法重载：

只要类名相同参数不完全相同的两个方法都属于方法重载；

示列：

package com.test;
 

public class Classes{

    public void test4() {
        System.out.println("子类方法重写");
    }
    public void test4(int i){
        
    }
    public void test4(String str){
        
    }
    public void test4(String str,int i){
        
    }
    public void test4(int i ,String str){
        
    }
}

3.构造方法：

每个类都会默认一个参数空的构造方法，在实例化该类的时候便会默认调用该构造方法；但也可以写一个参数不为空的构造方法，如果要调用的话，在实例化该类的时候添加一个对应类型的值便可，此时调用的便不是默认的构造方法而是自己写的构造方法；

示列：

package com.test;

public class Classes{
    public Classes(){
        System.out.println("String");
    }
    public Classes(int i){
        System.out.println("int");
    }

}

package com.test;

public class Main {
    public static void main(String[] args) {
        Classes classese = new Classes();
        Classes classese1=new Classes(1);
    }

}

最后打印出来的结果为：String

                                      int

三、对象（引用数据类型）与变量（基本数据类型）

这里主要说的是对象与变量的区别:

简单的来说对象new了一个实例化对象而变量没有，也就是说对象开辟了一个新的内存空间，而变量使用的是栈内存；因此，对象可以调用方法与属性，而变量不能；从某种意义上来说，变量只是起到了传值的作用而已，所以变量可以说只能用八大基本数据类型来定义；同时在这里说说八大基本数据类型的包装类以及拆箱与装箱，与包装类相对的便是基本类型；

八大基本数据类型的包装类：

byte--Byte

short--Short

int--Integer

long--Long

char--Character

float--Float

double--Double

boolean--Boolean

示列：

double i=1.2; //定义了一个double类型的变量;基本类型。

Double iii=1.2//double类型的对象；由于是用Double直接定义的，所以为自动装箱。

Double iii=new  Double(1.2);//double类型的对象；由于是new出来的对象，所以为手动装箱。

double ie=iii+i；//由于i是基本数据型，iii是包装类，如果要和基本数据类型i进行运算就得自动拆箱成基本数据类型；这就是自动拆箱。

int a=(int) i;//double变量转换为int类型，强制转换；

int aa=ii.intValue();//double对象转换为int类型

注：高精度的转为低精度，多出的小数部分不是四舍五入，而是直接舍弃。

Emma，最后再加一个命名规范吧：

类名：首字母大写+驼峰命名法（单词与单词间的首字母大写）；

方法名：首字母小写+驼峰命名法；

对象与类：首字母小写+驼峰命名法。