Java面向对象类和对象实例详解

目录
  • 1 - Java面向对象学习的三条主线
  • 2 - 面向过程与面向对象
  • 3 - 面向对象的三大特征
  • 4 - 面向对象分析方法分析问题的思路和步骤
  • 5 - 面向对象的思想概述
  • 6 - 类和对象的创建-内存解析
  • 7 - 类中属性的声明和使用(局部变量与成员变量的区别)
  • 8 - 类中方法的声明和使用
  • 9 - 对象数组的使用
  • 10 - 理解 "万物皆对象"
  • 11 - 匿名对象
  • 12 - 方法的封装(数组常用算法的封装)
  • 总结

1 - Java面向对象学习的三条主线

①Java类即类的成员:属性 方法 构造器 (代码块 内部类)

②面向对象的三大特征:封装性 继承性 多态性 (抽象性)

③其他关键字:this supper static final abstract interface 等

2 - 面向过程与面向对象

二者都是一种思想,面向对象是相对于面向过程而言的

  1-面向过程:强调的是功能行为,以函数为最小单位,考虑怎么做

  2-面向对象:将功能封装进对象,强调具备了功能的对象,以类/对象为最小单位,考虑谁来做

   面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则,如抽象,分类,继承,聚合,多态等

/*
人把大象装进冰箱
面向过程:强调的是功能行为,以函数为最小单位,考虑怎么做
    ①将冰箱门打开
    ②抬起大象,装进冰箱
    ③关闭冰箱门
面向对象:将功能封装进对象,强调具备了功能的对象,以类/对象为最小单位,考虑谁来做
    人{
        打开(冰箱){
            冰箱.开开门();
        }
        抬起(大象){
            大象.进入(冰箱);
        }
        关闭(冰箱){
            冰箱.闭合();
        }
    }
    冰箱{
        开开门(){}
        闭合(){}
    }
    大象{
        进入(冰箱){}
    }
 */

3 - 面向对象的三大特征

封装(Encapsulation)

继承(Inheritance)

多态(Polymorphism)

4 - 面向对象分析方法分析问题的思路和步骤

/*
* 程序员从面向过程的执行者转化成了面向对象的指挥着
* 面向对象分析方法分析问题的思路和步骤:
*    1-根据问题 需要,选择问题所针对的现实世界中的实体
*    2-从实体中寻找解决问题相关的属性和功能,这些属性和功能就形成了概念世界中的类
*    3-把抽象的实体用计算机语言进行描述,形成计算机世界中类的定义,即借助某种程序语言,把类构造成计算机能够识别和处理的 数据结构
*
*    4-将类实例化成计算机世界中的对象,对象是计算机世界中解决问题的最终工具
*/

5 - 面向对象的思想概述

1-类(Class)和对象(Object)是面向对象的核心概念:

  ①类是对一类事物的描述,是抽象的,概念上的定义

  ②对象是实际存在的该类事物的每个个体,因而也称其为实例(instance)

  ③Java世界里,"万物皆对象"

2-代码示例

/*
设计类 -> 其实就是设计类的成员
属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类

类和对象的使用(面向对象的思想实现)
    1-创建类,设计类的成员
    2-创建类的对象
    3-调用对象的属性或方法(对象.属性 对象.方法)

如果创建了一个类的多个对象,则每个对象都独立的拥有一套类的属性。(非 static 的)
意味着,我们修改一个对象的属性a,则不影响另一个对象的属性a。
 */
// 测试类
public class PersonTest {
    public static void main(String[] args){
        // 创建Person类的对象
        Person p1 = new Person();
        // Scanner scanner = new Scanner(System.in);
        // 调用对象属性:对象.属性
        System.out.println(p1.age); // 22
        p1.name = "howie";
        p1.isMale = true;

        // 调用对象方法:对象.方法
        p1.eat();
        p1.sleep();
        p1.talk("chinese");

        // *******************
        Person p2 = new Person();
        System.out.println(p2.name); // null 说明类的初始化默认值为 null

        Person p3 = p1; // 将p1变量保存的对象空间地址值赋值给p3,导致p1和p3都指向了堆空间的同一个对象实体
        System.out.println(p3.name); // howie
    }
}
// 创建类,设计类的成员
class Person{
    // 属性
    String name;
    int age = 22;
    boolean isMale;

    // 方法
    public void eat(){
        System.out.println("人正在吃饭!");
    }
    public void sleep(){
        System.out.println("人可以睡觉!");
    }
    public void talk(String language){
        System.out.println("人可以说话,使用的是"+language);
    }
}

6 - 类和对象的创建-内存解析

1-内存解析

2-对象内存解析

7 - 类中属性的声明和使用(局部变量与成员变量的区别)

1-属性(成员变量)vs 局部变量
* 1-相同点
*   ①定义变量的格式:数据类型 变量名 = 变量值
*   ②先声明,后使用
*   ③变量都有其对应的作用域
* 2-不同点
*   ①在类中声明的位置不同
*     属性:直接定义在类的一对{}内
*     局部变量:声明在方法内,方法形参,代码块,构造器形参,构造器内部的变量
*   ②关于权限修饰符的不同
*     属性:可以在声明属性时,指定其权限,使用权限修饰符。常用的权限修饰符:private , public , 缺省 , protected
*     目前,大家声明属性时,都使用缺省就可以(什么都不加)
*     局部变量:不可以使用权限修饰符
*   ③默认初始化的值
*     属性:类的属性,根据其类型,都有默认初始值。
*       整型(byte、short、int、long):0
*       浮点型(float、double):0.0
*       字符型(char):0(或'\u00000')
*       布尔(boolean):false
*
*       引用数据类型(类、数组、接口):null
*     局部变量:没有默认初始化值,意味着我们在调用局部变量之前,一定要显示赋值,特别的,形参调用时赋值即可。
*   ④在内存中加载的位置
*     属性:堆空间(非static)
*     局部变量:栈

public class test1 {
    public static void main(String[] args) {
        User u1 = new User();
        System.out.println(u1.name);
        System.out.println(u1.age);
        System.out.println(u1.isMale);
        // 调用形参
        u1.talk("English");
    }
}
class User{
    // 属性(或成员变量)
    String name;
    int age;
    boolean isMale;
    public void talk(String language) {// 形参,也是局部变量
        System.out.println("我们使用"+language+"交流");
    }

    public void eat() {
        String foot = "米线"; // 在方法中定义的局部变量
        System.out.println("云南人喜欢吃:"+foot);
    }
}

⑤内存解析需要注意两点

1-内存结构:栈(局部变量)、堆[new 出来的结构:对象(非 static成员变量)、数组]
2-变量:成员变量 vs 局部变量(方法内、方法形参、构造器内、构造器形参、代码块内)

8 - 类中方法的声明和使用

类中方法的申明和使用

  方法:描述类应该具备的功能

  比如 Math类:aqrt()\random()...

  Scanner类:nexInt() ...

  Arrays类:sort() \ binarySearch() \ toString() \ equals() \ ...

1-举例

  public void eat() {}
  public void sleep(int hour) {}
  public String getName() {}
   public String getNation(String nation) {}

2-方法的声明

  权限修饰符 返回值类型 方法名(形参列表) {
    方法体
  }

注意:static final abstract 来修饰的方法,后面在介绍

3-说明

  ①权限修饰符:Java规定的4种权限修饰符:private(私有的) , public , 缺省 , protected

    默认方法的权限修饰符先都使用public

  ②返回类型:有返回值 vs 没有返回值

    1-如果方法有返回值,则必须在方法声明时,指定返回值的类型。同时,方法中,需要使用时return关键字来返回指定类型的变量或常量

    2-如果方法没有返回值,则方法声明时,使用 void来表示。通常没有返回值的方法中,就不需要使用return关键字了

  ③方法名:属于标识符,遵循标识符的规则和规范,见名知意

  ④形参列表:方法可以声明0个,1个,或多个形参...格式:数据类型1 形参1,数据类型2 形参2,...

  ⑤方法体:方法功能的体现

4-return关键字的使用

  ①使用范围:使用在方法体中

  ②作用:1.结束方法2.针对于有返回值类型的方法,使用 'return 数据'方法返回所要的数据。

  ③注意点:return关键字后面不可以声明执行语句

5-方法的使用:可以调用当前类的属性或方法

  特殊的:方法A中调用方法A称作 递归方法

  方法中不可以再定义方法

public class CustomerTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    }
}

// 客户类
class Customer{
    // 属性
    String name;
    int age;
    boolean isMale;

    // 方法
    public void eat() {
        System.out.println("客户吃饭");
    }

    public void sleep(int hour) {
        System.out.println("客户休息了"+hour+"个小时");
    }

    public String getName() {
        return name;
    }

    public String getNation(String nation) {
        String info = "我的国籍是"+nation;
        return info;
    }
}

练习题

/*
 * 1-编写程序,声明一个method方法,在方法中打印一个10*8的*型矩形,在main方法中调用该方法。
 * 2-修改上一个程序,在method方法中,除打印一个10*8的*矩形外形,再计算该矩形的面积,并将其作为方法返回值。
 *         在main方法中调用该方法接受返回的面积值打印。
 *
 * 3-修改上一个程序,在method方法提供m和n两个参数,方法中打印一个m*n的*型矩形
 */
public class Exer3Test {
    public static void main(String[] args) {
        Exer3Test test = new Exer3Test();
        // 第1题的测试
        // test.method();

        // 第2题的测试
//        double s = test.method();
//        System.out.println("面积为"+s);

        // 第3题的测试
        System.out.println(test.method(12,10));
    }

        // 第1问
//    public void method(){
//        for(int i = 0;i < 10;i++){
//            for(int j = 0;j < 8;j++){
//                System.out.print("* ");
//            }
//            System.out.println();
//        }
//    }
    // 第2问
//    public double method(){
//        for(int i = 0;i < 10;i++){
//            for(int j = 0;j < 8;j++){
//                System.out.print("* ");
//            }
//            System.out.println();
//        }
//        return 10*8;

    // 第3问
    public int method(int n,int m){
        for(int i = 0;i < n;i++){
            for(int j = 0;j < m;j++){
                System.out.print("* ");
            }
            System.out.println();
        }
        return n * m;
    }
}

9 - 对象数组的使用

/*
 * 对象数组题目
 * 定义类Student,包含三个属性:学号number(int),年级state(int),成绩score(int)。创建20个学生对象,学号1到20
 *      年级[1-6]和成绩[0-100]都由随机数确定。
 * 问题1:打印出3年级(state值为3)的学生信息
 * 问题2:使用冒泡排序按学生成绩排序,并遍历所有学生信息
 *
 * 提示:
 *         ①生成随机数:Math.random(),返回值类型double
 *         ②四舍五入:Math.round(double d),返回值类型long.
 */

public class StudentTest {
    public static void main(String[] args){
        // 声明Student对象数组
        Student[] students = new Student[20];
        for(int i = 0;i < students.length;i++){
            // 给数组元素赋值
            students[i] = new Student();
            // 给Student对象的属性赋值
            students[i].number = i + 1;
            double value = Math.random();
            students[i].state = (int)(value * (6 - 1 + 1) + 1);
            double v = Math.random();
            students[i].score = (int)(v * (100 + 1) + 0);
            // System.out.print(students[i].score+"\t");
        }
        // 遍历学生数组
        for(int i = 0;i < students.length;i++){
            // System.out.println(students[i].number+","+students[i].state+","+students[i].score);
            // System.out.println(students[i].showInfo());

            // 问题1:打印出3年级(state值为3)的学生信息
            if(students[i].state == 3){
                // System.out.println(students[i].showInfo());
            }
        }
        // 问题2:使用 [冒泡排序] 按学生成绩排序,并遍历所有学生信息
        for(int i = 0;i < students.length - 1;i++){
            for(int j = 0;j < students.length - 1 - i;j++){
                if(students[j].score > students[j+1].score){
                    Student temp = students[j];
                    students[j] = students[j+1];
                    students[j+1] = temp;
                }
            }
        }
        // 遍历 排好序的 学生信息 从最高分打印
        for(int i = 0;i < students.length;i++){
            System.out.println(students[students.length - i-1].showInfo());
        }
    }
}

class Student{
    int number; // 学号
    int state; // 年级
    int score; // 成绩

    public String showInfo(){
        return "学号:"+number+" "+"年级:"+state+" "+"成绩:"+score;
    }
}

对象数组使用示例

数组对象内存解析

10 - 理解 "万物皆对象"

/*
* 1-在Java语言范畴中,我们都将功能,结构等封装到类中,通过类的实例化,来调用具体的功能结构
*   >Scanner,String
*   >文件:File
*   >网络资源:URL
* 2-涉及到Java语言与前端HTML、后端的数据库交互时、前后端的结构在Java层面交互时,都体现为类、对象
*/

11 - 匿名对象

/*
 * 匿名对象的使用
 * 1-理解:我们创建的对象,没有显示的赋给一个变量名,即为匿名对象
 * 2-特征:匿名对象只能调用一次
 * 3-开发中使用:以下代码示例
 */
public class PhoneTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Phone p = new Phone();
        // p = null;
        System.out.println(p);
        p.sendEmail();
        p.playGame();

        // 匿名对象
        // new Phone().sendEmail();
        // new Phone().playGame();
        new Phone().price = 199;
        new Phone().showPrice(); // 0.0

        PhoneMall mall = new PhoneMall();
        // mall.show(p);
        // 匿名对象的使用
        mall.show(new Phone());

    }
}
class PhoneMall{
    public void show(Phone phone) {
        phone.sendEmail();
        phone.playGame();
    }
}

class Phone{
    double price; // 价格

    public void sendEmail() {
        System.out.println("发送邮件");
    }
    public void playGame() {
        System.out.println("打游戏");
    }
    public void showPrice() {
        System.out.println("手机价格为"+price);
    }
}

匿名对象的使用

12 - 方法的封装(数组常用算法的封装)

注意两个Java文件在同级目录

①在ArrayUtils.java 文件中 创建类并分装方法

public class ArrayUtils {
    // 求数组最大值
    public int getMax(int[] array){
        int max = array[0];
        for(int i = 1;i < array.length;i++){
            if(array[i] > max){
                max = array[i];
            }
        }
        return max;
    }
    // 求数组最小值
    public int getMin(int[] array){
        int min = array[0];
        for(int i = 1;i < array.length;i++){
            if(min > array[i]){
                min = array[i];
            }
        }
        return min;
    }
    // 求数组总和
    public int getSum(int[] array){
        int sum = 0;
        for(int i = 0;i < array.length;i++){
            sum += array[i];
        }
        return sum;
    }
    // 求数组平均值
    public double getAvg(int[] array){
        return getSum(array) / array.length;
    }
    // 反转数组
    public void reverseArray(int[] array){
        for(int i = 0;i < array.length / 2;i++){
            int temp = array[i];
            array[i] = array[array.length - i - 1];
            array[array.length - i - 1] = temp;
        }
    }
    // 复制数组
    public int[] copyArray(int[] array){
        int[] newArray = new int[array.length];
        for(int i = 0;i < array.length;i++){
            newArray[i] = array[i];
        }
        return newArray;
    }
    // 数组排序
    public void sortArray(int[] array){
        /**
         * 默认从小到大排
         */
        for(int i = 0;i < array.length - 1;i++){
            for(int j = 0;j < array.length - i -1;j++){
                if(array[j] > array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }
    // 遍历数组
    public void print(int[] array){
        for(int i = 0;i < array.length;i++){
            System.out.print(array[i]+"\t");
        }
    }
    // 查找数组指定的元素
    public int getIndex(int[] array,int dest){
        int head = 0;
        int end = array.length - 1; // 初始的末索引
        boolean isFlag = false;
        int middle = 0;
        sortArray(array);
        while(head <= end){
            middle = (head + end) / 2;
            if(dest == array[middle]){
                isFlag = true;
                break;
            }else if(dest > array[middle]){
                head = middle + 1;
            }else{
                end = middle - 1;
            }
        }
        if(isFlag){
            return middle;
        }else{
            return -1;
        }
    }
}
ArrayUtils.java

②在ArrayUtilsTest.java 文件中测试封装好的方法

public class ArrayUtilsTest {
    public static void main(String[] args){
        ArrayUtils array = new ArrayUtils();
        int[] arr = new int[]{1,5,7,9,845,21,30,12,222,56,-30};
        // 获取数组最大值
        System.out.println(array.getMax(arr));

        // 获取数组最小值
        System.out.println(array.getMin(arr));

        // 数组反转
        array.reverseArray(arr);
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out.println();

        // 数组复制
        int[] arr2 = new int[]{1,2,3};
        int[] newArray = array.copyArray(arr2);
        for(int i = 0;i < newArray.length;i++){
            System.out.print(newArray[i]+"\t");
        }
        System.out.println();

        // 查找元素
        int i = array.getIndex(arr2,4);
        System.out.println(i); // -1 表示没有找到此元素

        // 数组排序
        int[] array3 = new int[]{1,5,8,77,98,33,0,2};
        ArrayUtils a = new ArrayUtils();
        System.out.print("排序前:");
        a.print(array3);
        System.out.println();

        System.out.print("排序后:");
        a.sortArray(array3);
        a.print(array3);
    }
}
ArrayUtilsTest.java

总结

到此这篇关于Java面向对象类和对象的文章就介绍到这了,更多相关Java面向对象类和对象内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java 全方位讲解面向对象特点与使用

    目录 面向过程和面向对象的区别 类和对象的关系 类和对象的创建 类的创建 对象的创建 构造器 构造器重载 this的使用 static修饰 代码块 包(import) 面向过程和面向对象的区别 面向过程:当事件比较简单的时候,利用面向过程,注重的是事件的具体步骤和过程,注重的是过程中的具体行为,以函数为最小单位,考虑怎么做. 面向对象:注重找“参与者”,将功能封装进对象中,强调具备了功能的对象,以类/对象为最小单位,考虑谁来做. 案例:小明从冰箱里拿东西 面向过程: 面向对象: 面向过程 —>

  • 理解Java面向对象编程设计

    目录 1 前言 2 结构化程序设计 3 面向对象编程设计 4 码农洞见 4.1 两种编程范式之间的区别 4.2 两种编程范式之间的联系 1 前言 计算机革命的起源来自机器.编程语言就像是那台机器.它不仅是我们思维放大的工具与另一种表达媒介,更像是我们思想的一部分.语言的灵感来自其他形式的表达,如写作,绘画,雕塑,动画和电影制作.编程语言就是创建应用程序的思想结构. 面向对象编程(Object-Oriented Programming OOP)是一种编程思维方式和编码架构. 2 结构化程序设计 结

  • Java 深入浅出解析面向对象之抽象类和接口

    目录 抽象类 声明抽象类 声明抽象方法 案例 使用规则 接口 声明接口 案例 接口特性 抽象类和接口的区别 抽象类 java语言,声明类时 abstract class Db{} 说明Db类为抽象类. java语言中,抽象方法是说没有方法的实现(方法体)此方法为抽象方法,只有抽象类和接口中才可以有抽象方法. 声明抽象类 声明抽象类很简单,加个abstract关节字就行. public abstract class AA { } 声明抽象方法 在抽象类中声明一个抽象方法,抽象方法没有方法体,就是说

  • Java面向对象之类的继承介绍

    目录 继承的作用 如果没有继承机制是怎么样的? 使用继承机制后的示例? 类的继承是什么? 子类和父类的继承机制 Java单继承 Java继承的顶级父类:Object 对象的类型转换 对象向上转型 对象向下转型 总结 继承的作用 如果没有继承机制是怎么样的? 有以下两个类,分别是Student.Teacher,它们的实现类如下: /** * 老师类 封装了姓名.年龄 * * @author Administrator * */ public class Teacher { private Stri

  • Java十分钟精通包装类的使用与操作

    包装类 何为包装类? 基本类型包装类的概述: 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据 包装类是将基本数据类型的值包装为Java中的对象,Java语言为8种基本数据类型分别提供了包装类 首先看一下八大数据类型的包装类: 包装类型出现的原因: 因为Java是一个面向对象的语言,基本类型并不具有对象的性质,为了与其他对象"接轨"就出现了包装类型,它相当于将基本类型"包装起来",使得它具有了对象的性质,并且为其添加了属性和方法,丰富了基本

  • java面向对象继承与多态介绍

    目录 一.概述 二.继承 2.1 继承的概述 2.2 继承机制 2.3 类中属性,方法的继承与覆盖 2.4 super 关键字 三. 多态 总结 一.概述 面向对象程序设计的三大原则是封装性,继承性和多态性.继承性是子类自动共享父类的数据和方法的机制,它是由类的派生功能体现的.继承具有传递性,使得一个类可以继承另一个类的属性和方法,这样通过抽象出共同的属性和方法组件新的类,便于代码的重用.而多态是指不同类型的对象接收相同的消息时产生不同的行为,这里的消息主要是对类成员函数的调用,而不同的行为是指

  • 学生视角看Java 面向对象的继承本质

    1.什么是继承? (1)用来提高代码的复用性 (2)将相同的功能模块封装到方法中需要使用时调用方法达到代码复用的目的 (3)通过继承将多个类中的相同的类容摘取出来,变成一个新类,让其他类和当前的新类产生关系,达到代码复用性的目的 注意:Java是单继承与c++有区别 ,c++可以多继承. 2.继承的格式 关键字extends 3.继承的特性 *子类拥有父类非 private 的属性.方法. *子类可以拥有自己的属性和方法,即子类可以对父类进行扩展. *子类可以用自己的方式实现父类的方法. *Ja

  • Java面向对象类和对象实例详解

    目录 1 - Java面向对象学习的三条主线 2 - 面向过程与面向对象 3 - 面向对象的三大特征 4 - 面向对象分析方法分析问题的思路和步骤 5 - 面向对象的思想概述 6 - 类和对象的创建-内存解析 7 - 类中属性的声明和使用(局部变量与成员变量的区别) 8 - 类中方法的声明和使用 9 - 对象数组的使用 10 - 理解 "万物皆对象" 11 - 匿名对象 12 - 方法的封装(数组常用算法的封装) 总结 1 - Java面向对象学习的三条主线 ①Java类即类的成员:属

  • java枚举类的构造函数实例详解

    java枚举类的构造函数实例详解 首先,给出一个例题如下: enum AccountType { SAVING, FIXED, CURRENT; private AccountType() { System.out.println("It is a account type"); } } class EnumOne { public static void main(String[]args) { System.out.println(AccountType.FIXED); } } T

  • Python面向对象之类和对象实例详解

    本文实例讲述了Python面向对象之类和对象.分享给大家供大家参考,具体如下: 类和对象(1) 对象是什么? 对象=属性(静态)+方法(动态): 属性一般是一个个变量:方法是一个个函数: #类的属性 就是 类变量 #实例变量:定义在方法中的变量,只作用于当前实例的类. 例子: class Turtle:#python 中类名约定以大写字母开头 '''关于类的简单例子...''' #属性 == 类变量 color ="green" weight="10kg" legs

  • Python面向对象类的继承实例详解

    本文实例讲述了Python面向对象类的继承.分享给大家供大家参考,具体如下: 一.概述 面向对象编程 (OOP) 语言的一个主要功能就是"继承".继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展. 通过继承创建的新类称为"子类"或"派生类",被继承的类称为"基类"."父类"或"超类",继承的过程,就是从一般到特殊的过程.在某些 OOP

  • Java语言面向对象编程思想之类与对象实例详解

    在初学者学Java的时候,面向对象很难让人搞懂,那么今天小编就来为大家把这个思想来为大家用极为简单的方法理解吧. 首先我们来简单的阐述面向对象的思想. 面向对象: 官方的语言很抽象,我们把官方的解释和定义抛开.想想,自己有什么,对!!我们自己有手脚眼口鼻等一系列的器官.来把自己所具有的器官就可以看作我们的属性,自己是不是可以喜怒哀乐和嬉笑怒骂,这些是不是我们的行为,那么自己的具有的属性加自己有的行为就称为一个对象. 注意!!我们自己,一个个体是一个对象,因为,你是你,我是我,我们虽然有相同的,但

  • Java类的继承实例详解(动力节点Java学院整理)

    一.你了解类吗? 在Java中,类文件是以.java为后缀的代码文件,在每个类文件中最多只允许出现一个public类,当有public类的时候,类文件的名称必须和public类的名称相同,若不存在public,则类文件的名称可以为任意的名称(当然以数字开头的名称是不允许的). 在类内部,对于成员变量,如果在定义的时候没有进行显示的赋值初始化,则Java会保证类的每个成员变量都得到恰当的初始化: 1)对于  char.short.byte.int.long.float.double等基本数据类型的

  • Java创建内部类对象实例详解

    Java创建内部类对象实例详解 要想使用new生成一个内部类的实例,需要先指向一个外部类的实例,也就是先生成外部类的实例, 因为内部类可以调用外部类的成员,当没有外部类实例的时候也就没有这些成员的内存空间,内部类在实例化的时候,调用外部类的成员就会出错,所以需要使用外部类的实例 + 点 + new 的方式实例化一个新的内部类 class TestInner{ public static void main(String [] args) { Outer outer = new Outer();

  • Java中Properties类的操作实例详解

    Java中Properties类的操作实例详解 知识学而不用,就等于没用,到真正用到的时候还得重新再学.最近在看几款开源模拟器的源码,里面涉及到了很多关于Properties类的引用,由于Java已经好久没用了,而这些模拟器大多用Java来写,外加一些脚本语言Python,Perl之类的,不得已,又得重新拾起.本文通过看<Java编程思想>和一些网友的博客总结而来,只为简单介绍Properties类的相关操作.  一.Java Properties类 Java中有个比较重要的类Properti

  • java操作mongoDB查询的实例详解

    java操作mongo查询的实例详解 前言: MongoDB是一个基于分布式文件存储的数据库.由C++语言编写.旨在为WEB应用提供可扩展的高性能数据存储解决方案. MongoDB是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的.他支持的数据结构非常松散,是类似json的bson格式,因此可以存储比较复杂的数据类型.Mongo最大的特点是他支持的查询语言非常强大,其语法有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,而且

  • JSP的request对象实例详解

    JSP的request对象实例详解 一 request对象定义 客户端的请求信息被封装在request对象中,通过它才能了解客户的需求,然后做出响应.它是HttpServletRequest类的实例.request对象具有请求域,即完成客户端的请求之前,该对象一直有效. 二 request对象方法 三 实例 <%@ page language="java" import="java.util.*" contentType="text/html; ch

随机推荐