精华内容
下载资源
问答
  • java中类定义的变量和类方法里面定义的变量有什么区别和联系 为什么要再方法当中定义变量,统一在类里面,方法外面定义变量不是更方便快捷么
  • java中类定义位置与分类

    千次阅读 2016-12-21 21:07:22
    java中最常见的定义位置是文件,一个文件可以定义多个,但是只能有一个public的,而且java文件名必须和这个public相同。看看下面代码package com.senmu.pack_a //TestA.java public class TestA{} ...

    在java中,类最常见的定义位置是文件中,一个文件中可以定义多个类,但是只能有一个public的类,而且java文件名必须和这个public类相同。看看下面代码

    package com.senmu.pack_a
    //TestA.java
    public class TestA{}
    class TestB{}
    class TestC{}

    这里有一个TestA.java的源文件,里面定义了三个class。可以看出一个源文件里能定义多个class,但是有且只能有一个public类,非public类的名字只要符合java标识符规则就可以,public类的名字必须和源文件名一致。至于为什么有这个规定,很多网上的帖子都说是为了方便JVM根据文件名找到main函数入口,个人觉得这种说法不太可信也不太合理。原因如下,JVM读取的是编译后的.class文件而不是.java源文件,而定义在一个源文件中的多个类编译后都生成了由各自类名命名的.class文件。在我看来当初java的设计者这样规定的主要目应该是为了给源码阅读提供便利,试想一下如果一个源文件中可以有多个public的class而且名字与源文件名不一致,那么当我们在阅读代码时想要了解某个引用类的定义情况应该去哪找这个类的源代码呢?当有了这个规定之后我们就可以根据import的包名和类名准确找到源文件的位置。至于源文件中的其他非public类,他们只能被本包内的类使用,使用范围有限,命名也就没有严格要求了。

    类除了可以定义在文件中还可以定义在其他类中。定义在其他类中的类成为内部类,内部类又可以分成成员内部类和内嵌内部类,其区别在于是否被static修饰符修饰。成员内部类可以访问外部类的所有成员属性和方法,内嵌内部类和普通类没有什么区别只是加了外部类命名限定而已。如下面代码。

    package com.senmu.pack_a
    //TestA.java
    public class TestA{
        private int f1;
        private int f2;
    
        public TestA(int f1,int f2){
            this.f1 = f1;
            this.f2 = f2;
        }
        public int cal{
            return new TestAInner1().cal();//在外部类中可以像普通类一样使用
        }
        public class TestAInner1{
            public int cal(){
                return f1+f2;//成员内部类可以直接访问外部类的所有公有及私有属性。
            }
        }
        public static class TestInner2{
            public int cal(){
                //return f1+f2 编译错误,因为内嵌内部类不能访问外部类的成员属性。
            return 0;
            }
        }
    }
    package com.senmu.pack_b
    import com.senmu.pack_a.TestA;
    //TestB.java
    public class TestB{
        private TestA.TestAInner ti = new TestA.TestAInner();//TestA.TestInner是内嵌内部类,可以和普通类一样使用
        public void test(){
            TestA ta = new TestA();
            ta.new TestInner1().cal();//在其他类中使用TestA的成员内部类。
    
        }
    }

    最后,java中的类还可以定义在方法中,定义在方法中的类只能在方法中使用,可以看到所有对方法可见的变量。

    package com.senmu.pack_a
    //TestA.java
    public class TestA{
        private int f1;
        private int f2;
    
        public TestA(int f1,int f2){
            this.f1 = f1;
            this.f2 = f2;
        }
        public int cal(int a){
            class MethodInner{
                public int test(){
                    return a + f1 +f2;//方法中内部类可以访问对方法可见所以变量
                }
            }
            return new MethodInner().test();//方法中的内部类只能在本方法中使用。
    }
    展开全文
  • Java中类定义

    千次阅读 2018-11-04 14:27:45
    在面向对象的程序设计语言是对一“事物”的属性与行为的抽象。举一个例子说明下,比如Person(人)就是一个,那么具体的某个人“张三”就是“人类”这个的对象,而“姓名、身高、体重”等信息就是对象...

    类就是具备某些共同特征的实体的集合,它是一种抽象的数据类型,它是对所具有相同特征实体的抽象。在面向对象的程序设计语言中,类是对一类“事物”的属性与行为的抽象。举一个例子说明下类,比如Person(人)就是一个类,那么具体的某个人“张三”就是“人类”这个类的对象,而“姓名、身高、体重”等信息就是对象的属性,人的动作比如“吃饭、穿衣”等就是对象的方法。总之类就是有相同特征的事物的集合,而对象就是类的一个具体实例。同时类有多态和继承,例如“人类”可以分为“男人、女人”,“老人、小孩”那么“男人、女人”就是“人类”的子类等等。
    Java语言中对类Person的定义往往如下:

    public class Person {
    private String name; //属性:姓名

    private int height; //属性:身高

    private int weight; //属性:体重

    public Person() {}

    public Person(String name, int height, int weight) {

    this.name = name;

    this.height = height;

    this.weight = weight;

    }

    //… some methods…

    public void doSth() { //行为:

    //… do something

    }}

    Java中的类

    类可以看成是创建Java对象的模板。

    通过下面一个简单的类来理解下Java中类的定义:

    public class Dog{ String breed; int age; String color; void barking(){ } void hungry(){ } void sleeping(){ }}

    一个类可以包含以下类型变量:

    局部变量:在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。

    成员变量:成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

    类变量:类变量也声明在类中,方法体之外,但必须声明为static类型。

    一个类可以拥有多个方法,在上面的例子中:barking()、hungry()和sleeping()都是Dog类的方法。

    展开全文
  • Java类中定义接口

    千次阅读 2018-05-08 16:45:49
    一、类中定义接口</strong> [java] view plain copypackage com.dao.util; public class Util { public interface Worker { void work(); } } package com.dao.util; i...
    1. <strong>一、类中定义接口</strong>  
    [java]  view plain  copy
    1. package com.dao.util;  
    2.   
    3. public class Util {  
    4.     public interface Worker {  
    5.         void work();  
    6.     }  
    7. }  
    8.     
    9. package com.dao.util;  
    10.   
    11. import com.dao.util.Util.Worker;  
    12.   
    13. public class Demo implements Worker {  
    14.     public void work() {  
    15.         System.out.println("Is working");  
    16.     }  
    17. }  
    在这个util类里面封装了会改变的Worker,也就是说,util类里面有自己的算法:一部分是固定,另外一部分是可变的,而这个可变的部分就变成了一个接口(接口是特殊的抽象类~其实的意思大概的这个worker可能在不同的工作环境有不同的工作方式,例如work(),onvaction())

    所以在类里面放一个接口不是什么新的设计,而是一种思想方式,让代码扩展性更高

    二、java内部类使用


    解析:原来我写的内部类是动态的,也就是开头以public class开头。而主程序是public static class main。在Java中,类中的静态方法不能直接调用动态方法。只有将某个内部类修饰为静态类,然后才能够在静态类中调用该类的成员变量与成员方法。所以在不做其他变动的情况下,最简单的解决办法是将public class改为public static class.

    展开全文
  • Java中数组的定义与使用(一)

    万次阅读 多人点赞 2018-09-01 00:05:13
    如果说现在要求你定义100个整型变量,那么如果按照之前的做法,可能现在定义的的结构如下: int i1, i2, i3, ... i100; 但是这儿时候如果按照此类方式定义就会非常麻烦,...

    数组的基本概念

    如果说现在要求你定义100个整型变量,那么如果按照之前的做法,可能现在定义的的结构如下:

    int i1, i2, i3, ... i100;
    

    但是这个时候如果按照此类方式定义就会非常麻烦,因为这些变量彼此之间没有任何的关联,也就是说如果现在突然再有一个要求,要求你输出这100个变量的内容,意味着你要编写System.out.println()语句100次。

    其实所谓的数组指的就是一组相关类型的变量集合,并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型,那么既然是引用数据类型,这里面实际又会牵扯到内存分配,而数组的定义语法有如下两类。

    • 数组动态初始化:
      • 声明并开辟数组:
        • 数据类型 [] 数组名称 = new 数据类型[长度];
        • 数据类型 [] 数组名称 = new 数据类型[长度];
      • 分布进行数组空间开辟(实例化)
        | Tables | Are |
        | ------------- |:-------------?
        | 声明数组: | 数组类型 数组名称[] = null; | | | 数组类型 [] 数组名称 =null; | | 开辟数组空间: | 数组名称 =new` 数组类型[长度]; |

    那么当数组开辟空间之后,就可以采用如下的方式的操作:

    • 数组的访问通过索引完成,即:“数组名称[索引]”,但是需要注意的是,数组的索引从0开始,所以索引的范围就是0 ~ 数组长度-1,例如开辟了3个空间的数组,所以可以使用的索引是:0,1,2,如果此时访问的时候超过了数组的索引范围,会产生java.lang.ArrayIndexOutOfBoundsException 异常信息;
    • 当我们数组采用动态初始化开辟空间后,数组里面的每一个元素都是该数组对应数据类型的默认值;
    • 数组本身是一个有序的集合操作,所以对于数组的内容操作往往会采用循环的模式完成,数组是一个有限的数据集合,所以应该使用 for 循环。
    • Java 中提供有一种动态取得数组长度的方式:数组名称.length;

    范例: 定义一个int型数组

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = new int[3]; /*开辟了一个长度为3的数组*/
    		data[0] = 10; // 第一个元素
    		data[1] = 20; // 第二个元素
    		data[2] = 30; // 第三个元素
    		for(int x = 0; x < data.length; x++) {
    			System.out.println(data[x]); //通过循环控制索引
    		}
    	}
    }
    

    数组本身除了声明并开辟空间之外还有另外一种开辟模式。

    范例: 采用分步的模式开辟数组空间

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null; 
    		data = new int[3]; /*开辟了一个长度为3的数组*/
    		data[0] = 10; // 第一个元素
    		data[1] = 20; // 第二个元素
    		data[2] = 30; // 第三个元素
    		for(int x = 0; x < data.length; x++) {
    			System.out.println(data[x]); //通过循环控制索引
    		}
    	}
    }
    

    但是千万要记住,数组属于引用数据类型,所以在数组使用之前一定要开辟控件(实例化),如果使用了没有开辟空间的数组,则一定会出现 NullPointerException 异常信息:

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null; 
    		System.out.println(data[x]);
    	}
    }
    

    这一原则和之前讲解的对象是完全相同的。

    数组在开发之中一定会使用,但是像上面的操作很少。在以后的实际开发之中,会更多的使用数组概念,而直接使用,99%情况下都只是做一个 for 循环输出。

    数组引用传递

    既然数组属于引用数据类型,那么也一定可以发生引用传递。在这之前首先来研究一下数组的空间开辟。

    范例: 观察一道程序

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null;
    		data = new int[3]; //开辟一个长度为3的数组
    		data[0] = 10;
    		data[1] = 20;
    		data[2] = 30;
    	}
    }
    

    新建数组变量

    那么既然说到了引用数据类型了,就一定可以发生引用传递,而现在的引用传递的本质也一定是:同一块堆内存空间可以被不同的栈内存所指向。

    范例: 定义一个程序

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = null;
    		data = new int[3]; //开辟一个长度为3的数组
    		int temp[] = null; //声明对象
    		data[0] = 10;
    		data[1] = 20;
    		data[2] = 30;
    		temp = data;  //int temp[] = data;
    		temp[0] = 99;
    		for(int i = 0; i < temp.length; i++) {
    			System.out.println(data[i]);
    		}
    	}
    }
    

    这里写图片描述

    引用传递分析都是一个套路。同一块堆内存被不同的栈内存所指向。

    数组静态初始化

    在之前所进行的数组定义都有一个明显特点:数组先开辟内存空间,而后再使用索引进行内容的设置,实际上这种做法都叫做动态初始化,而如果希望数组在定义的时候可以同时出现设置内容,那么就可以采用静态初始化完成。

    数组的静态初始化一共分为以下两种类型:

    TablesAre
    简化格式:数据类型 数组名称 = {值, 值,…}
    完整格式:数据类型 数组名称 = new 数据类型[] {值, 值,…}

    范例: 采用静态初始化定义数组

    public class ArrayDemo {
    	public static void main(String args[]) {
    		int data[] = {1, 2, 4, 545, 11, 32, 13131, 4444};
    		for(int i = 0; i < data.length; i++) {
    			System.out.println(data[i]);
    		}
    	}
    }
    

    在开发之中,对于静态数组的初始化强烈建议使用完整语法模式,这样可以轻松地使用匿名数组这一概念。

    public class ArrayDemo {
    	public static void main(String args[]) {
    		System.out.println(new int[] {1, 2, 4, 545, 11, 32, 13131, 4444}.length);
    	}
    }
    

    以后使用静态方式定义数组的时候一定要写上完整格式。

    数组最大的缺陷:长度固定。

    二维数组

    在之前所使用的数组发现只需要一个索引就可以进行访问,那么这样的数组实际上非常像一个数据行的概念。

    索引012345678
    内容122344569044549991010

    现在痛过一个索引就可以取得唯一的一个记录。所以这样的数组可以简单理解为一维数组,而二维数组本质上指的是行列集合,也如果要确定某一个数据需要行索引和列索引来进行定位。

    索引012345678
    0122344569044549991010
    1234156945499910

    如果要想确定一个数据则数据使用的结构是“数组名称[行索引][列索引]”,所以这样的结构就是一个表的结构。

    那么对二维数组的定义有两种声明形式:

    • 数组的动态初始化:数据类型 对象数组[][] = new 数据类型[行个数][列个数];
    • 数组的静态初始化:数据类型 对象数组[][] = new 数据类型[行个数][列个数]{{值, 值,…}, {值, 值,…},…};

    数组的数组就是二维数组。

    范例: 定义一个二维数组

    public class ArrayDemo {
    	public static void main(String args[]) {
    		//此时的数组并不是一个等列数组
    		int data[][] = new int[][] {
    			{1, 2, 3}, {4, 5}, {6, 7, 8, 9}};
    		//如果在进行输出的时候一定要使用双重循环,
    		//外部的循环控制输出的行数,而内部的循环控制输出列数
    		for(int i = 0; i < data.length; i++) {
    			for(int j = 0; j < data[i].length; j++) {
    				System.out.print("data[" + i + "][" + j + "]=" + data[i][j] + "、");
    			}
    			System.out.println();
    		}
    	}
    }
    

    由于输出麻烦,所以可以忽略了,在进行开发之中,出现二位数组的几率并不高。

    展开全文
  • Java中定义public

    千次阅读 2018-11-16 14:43:33
    1、一个”.java”源文件是否可以包括多个(不是内部)?有什么限制?   答:可以有多个,但只能有一个public的,并且public的类名必须与文件名相一致。 2、为什么一个文件只能有一个public的   ...
  • Java类中定义接口

    万次阅读 2016-11-26 15:30:31
    一、类中定义接口 package com.dao.util; public class Util { public interface Worker { void work(); } } package com.dao.util; import com.dao.util.Util.Worker; public class Demo implements Worker...
  • 在枚举的源代码,有这样的定义: Enum <E extends Enum<E>> 在网上看了很多人的文章都没有看懂,请能够解释清楚的大神帮忙说说。 E extends Enum到底有什么用? 为什么要这么写?
  • Java手机类定义

    千次阅读 2020-01-03 11:24:55
    加粗样式 package lesson02; public class demo01 { public static void main(String[] args) { // TODO Auto-generated method stub Phone ph1 = new Phone(); //给属性赋值 ph1.brand = "苹果";...
  • java类中定义常量的三中方法

    千次阅读 2018-07-15 00:00:16
    主要讲解如何在java类中定义常量:/** * Method One */ interface ConstantInterface { String SUNDAY = "SUNDAY"; String MONDAY = "MONDAY"; String TUESDAY = "TUESDAY"; ...
  • java中自己定义node来代表无线网络的节点,然后我怎么来仿真两个Node对象的通信。通信指的是虽然没有数据的发送但是存在逻辑上的通信
  • Java 的一种重要的...在 Java 中定义一个,需要使用 class 关键字、一个自定义的类名和一对表示程序体的大括号。完整语法如下: [public][abstract|final]class<class_name>[extends<class_name...
  • java中抽象定义和使用

    千次阅读 2016-11-02 16:54:34
    java虽然比较简单,但是细节的知识点还是很多的,现在,介绍一下抽象定义和实现基础。指的是在类中定义方法,而不去实现它,而在它的子类去具体实现,继承抽象的子类必须实现父类的抽象方法,除非子类是一个...
  • JAVA中类Cursor的定义

    万次阅读 2010-07-13 11:39:00
    Cursor是封装鼠标光标的位图表示形式的。 1.在java中所在的包 java.lang.Object  java.awt.Cursor   2.所有已实现的接口 Serializable  public class Cursor ext
  • 文章目录1 内部的基本概念1.1 内部定义1.2 内部的优缺点2 创建内部2.1 在外部外部创建非静态内部2.2 在外部外部创建静态内部2.3 在外部内部创建内部语法3 内部的分类3.1 成员内部3.2 静态...
  • Java类定义及其实例化

    千次阅读 2019-06-14 21:29:55
    类必须先定义才能使用。...下面通过一个简单的例子来理解Java中类定义: publicclassDog{ Stringname; intage; voidbark(){// 汪汪叫 System.out.println(“汪汪,不要过来”); } void...
  • Java中的Object

    万次阅读 多人点赞 2019-05-11 14:54:16
    Object作为所有的父类,是面向对象学习最重要的一个。Objectjava默认的提供的一个,Object是所有的父类,也就是说任何一个定义的时候如果没有明确的继承一个父类的话,那么它就是Object的子类
  • Java中类与对象的定义与使用

    千次阅读 多人点赞 2018-10-31 20:38:54
     把客观事物封装成抽象的,每个都有自己的属性与方法,并且可以让自己的数据和方法只让可信的或对象操作,对不可信的进行信息隐藏。内部操作对外部而言不可见(保护性) 0.2 继承性  它可以是现有的...
  • 只要一个是抽象的或是一个接口,那么其子类的方 法都可以使用匿名内部来实现  3.匿名内部的格式: new 父类或者接口(){定义子类的内容}  4.其实匿名内部就是一个匿名子类对象。而且这个对象有点胖。...
  • JAVA类中定义数组并赋值

    万次阅读 2019-01-15 15:25:46
    public class Deom { int a[]=new int[100]; a[0]=1234; a[1]=1234; a[2]=1234;...该段代码没有在任何方法体内,是永远不会执行的,所以java在编译的时候就提示出错。...当然,定义的同时初始化赋值是...
  • java中定义类的数组

    千次阅读 2014-03-01 14:59:52
     就申请了12个int的空间, 以后可以直接引用a[2], 但的数组定义不同, 比如以下是方式才可以定义一个包括3个Rect的数组  Rect rc[] = new Rect[3];  for(index = 0; index  { rc[index] = new Rect
  • java中抽象的子类可以定义为抽象吗?比如我可以在在抽象子类再扩展抽象方法
  • java类中定义接口的有哪些好处

    千次阅读 2016-04-29 11:01:06
    第一步:首先是是定义一个,同时里面定义接口 public class Util { ...第二步:定义一个去实现第一步类中定义的接口 public class Demo implements Worker { @Override public void work(int a)
  • Java泛型定义

    千次阅读 2019-06-22 19:15:18
    泛型类定义的语法如下: [访问修饰符]class名称 <T> 泛型的主要作用在于被实例化后,传入具体的类型参数,对的成员属性的类型和成员方法的参数类型和返回值类型进行替换。 二代码 public class ...
  • 这个我想请教一下,为什么这里能在类定义里实例化本的对象? 这里还列出了另一种方式: class Singleton { static Singleton instance =new Singleton(); private Singleton(){} public void print(){ System.out...
  • Java中类定义时对HashSet的初始化方法 http://blog.csdn.net/puqutogether/article/details/44344821 2016-11-25 18:16  Java中很多时候都要用到HashSet的查找功能,那么在定义时,数据成员假如...
  • 一、抽象与抽象方法的定义 抽象:只在普通的基础上扩充了一些抽象...抽象类中包含抽象方法,抽象方法不包含方法体,即抽象类中没有具体实现,所以抽象类中不能直接产生实例化对象 举例:创建一个简单的抽象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,668,307
精华内容 1,067,322
关键字:

java中类的定义

java 订阅