「java公共方法」java公共方法说明文档生成

今天给各位分享java公共方法的知识，其中也会对java公共方法说明文档生成进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java中怎么写一个公共的查询数据库方法？
• 2、java中好几个不同的实体类要调用某个公共的方法，公共方法的参数怎么写。
• 3、在java中包私有类的公共方法,其它包的类能访问吗
• 4、java里的public int doStuff(int factor)是什么意思？
• 5、JAVA里面的包，公共类和方法有什么区别
• 6、JAVA中public static void main(string[]args)中的(string[]args)是什么意思

java中怎么写一个公共的查询数据库方法？

package cn.db;//这个是自己建的包，这样子方便用的时候就可以通过包名来确定路径了

import java.sql.*;

import java.util.ArrayList;

public class DbDao {

Connection con=null;//连接

Statement stm=null;//执行SQL语句

ResultSet rs=null;//保存查询结果

public void connectDb(){

try {

Class.forName("com.mysql.jdbc.Driver");//这句固定的

con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/mydb","root","root");//其中的mydb是数据库名，后面两个root分别是数据库用户名和密码（我用的是MySQL数据库）

stm = con.createStatement();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

public ArrayList executeQuery(String sql){//这个方法是用来查询数据库的，并且将查询的数据放到链表中

ArrayList list = new ArrayList();

try {

rs = stm.executeQuery(sql);

while(rs.next()){

//这里写入你要查询的数据，得由你自己写了。

}

} catch (SQLException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

return list;

}

public void closeDb(){//关闭数据库

try {

if(rs!=null) rs.close();

if(stm!=null) stm.close();

if(con!=null) con.close();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

java中好几个不同的实体类要调用某个公共的方法，公共方法的参数怎么写。

因为，A，B，C没有继承公共超类，也没有实现公共接口，可以考虑使用泛型解决：

class 公共方法

{

public U void 方法1(ClassU cls,U obj)

{

U o=cls.cast(obj);

//调用o的方法

}

}

则这样使用这个类：

公共方法 cf=new 公共方法();

A a=new A();

cf.方法1(A.class,a);

B b=new B();

cf.方法1(B.class,b);

在java中包私有类的公共方法,其它包的类能访问吗

我知道你不想看测试的，所以直接给答案：

包私有类，其它包的类是不能访问的 ，那如果包私有类中的方法是Public呢 其它包的类还能访问这个方法吗

你说的私有类只可能是内部类，因为外部类是只有包或者公开访问权限的，

那如果包私有类中的方法是Public呢 其它包的类还能访问这个方法吗

我假设你提问的是内部类，不可以，因为它连这个类都访问不了,可以这样理解，一个私有内部类中的方法访问权限也肯定是private，不然的话，别人就可以访问了

测试一下内部类的情况：

package Lianxi.yong;

public class Test{

private class privateTest3{//内部类是可以声明为私有的

public void publciTest(){}

private void privateTest(){}

protected void protectedTest(){}

void defaultTest(){}

}

protected class ProtectedTest3{//内部类是可以声明为保护的

public ProtectedTest3(){}//要想要子类访问，这里必须把构造方法设置为public

public void publciTest(){}

private void privateTest(){}

protected void protectedTest(){}

void defaultTest(){}

}

class DefaultTest3{//内部类是可以声明为默认的

public void publciTest(){}

private void privateTest(){}

protected void protectedTest(){}

void defaultTest(){}

}

public class PublicTest3{//内部类是可以声明为公开的

public void publciTest(){}

private void privateTest(){}

protected void protectedTest(){}

void defaultTest(){}

}

public static void main(String[] args) {

(new Test()).new privateTest3().publciTest();//这个私有类这里可以访问,公有方法可以访问

(new Test()).new privateTest3().privateTest();//这个私有类这里可以访问,私有方法可以访问

(new Test()).new privateTest3().protectedTest();//这个私有类这里可以访问,保护方法可以访问

(new Test()).new privateTest3().defaultTest();//这个私有类这里可以访问,默认访问权限方法可以访问

(new Test()).new ProtectedTest3().publciTest();//这个保护类这里可以访问,公有方法可以访问

(new Test()).new ProtectedTest3().privateTest();//这个保护类这里可以访问,私有方法可以访问

(new Test()).new ProtectedTest3().protectedTest();//这个保护类这里可以访问,保护方法可以访问

(new Test()).new ProtectedTest3().defaultTest();//这个保护类这里可以访问,默认访问权限方法可以访问

(new Test()).new DefaultTest3().publciTest();//这个默认访问权限类这里可以访问,公有方法可以访问

(new Test()).new DefaultTest3().privateTest();//这个默认访问权限类这里可以访问,私有方法可以访问

(new Test()).new DefaultTest3().protectedTest();//这个默认访问权限类这里可以访问,保护方法可以访问

(new Test()).new DefaultTest3().defaultTest();//这个默认访问权限类这里可以访问,默认访问权限方法可以访问

(new Test()).new PublicTest3().publciTest();//这个公有类这里可以访问,公有方法可以访问

(new Test()).new PublicTest3().privateTest();//这个公有类这里可以访问,私有方法可以访问

(new Test()).new PublicTest3().protectedTest();//这个公有类这里可以访问,保护方法可以访问

(new Test()).new PublicTest3().defaultTest();//这个公有类这里可以访问,默认访问权限方法可以访问

}

}

//private class Test2{//根本就无法声明私有类

//

//}

测试不同包的情况：

package Lianxi.yong2;

import Lianxi.yong.Test;

public class Test2 {

public void test(){

(new Test()).new privateTest3().publciTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().privateTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().protectedTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().defaultTest();//这个私有类这里不可以访问

(new Test()).new ProtectedTest3().publciTest();//这个保护类这里不可以访问

(new Test()).new ProtectedTest3().privateTest();//这个保护类这里不可以访问

(new Test()).new ProtectedTest3().protectedTest();//这个保护类这里不可以访问

(new Test()).new ProtectedTest3().defaultTest();//这个保护类这里不可以访问

(new Test()).new DefaultTest3().publciTest();//这个默认访问权限类这里不可以访问

(new Test()).new DefaultTest3().privateTest();//这个默认访问权限类这里不可以访问

(new Test()).new DefaultTest3().protectedTest();//这个默认访问权限类这里不可以访问

(new Test()).new DefaultTest3().defaultTest();//这个默认访问权限类这里不可以访问

(new Test()).new PublicTest3().publciTest();//这个公有类这里可以访问,公有方法可以访问

(new Test()).new PublicTest3().privateTest();//这个公有类这里可以访问,私有方法不可以访问

(new Test()).new PublicTest3().protectedTest();//这个公有类这里可以访问,保护方法不可以访问

(new Test()).new PublicTest3().defaultTest();//这个公有类这里可以访问,默认访问权限方法不可以访问

}

}

测试相同包的情况：

package Lianxi.yong;

import Lianxi.yong.Test.DefaultTest3;

import Lianxi.yong.Test.ProtectedTest3;

import Lianxi.yong.Test.PublicTest3;

import Lianxi.yong.Test.privateTest3;

public class SamePackageTest {

public static void main(String[] args) {

(new Test()).new privateTest3().publciTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().privateTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().protectedTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().defaultTest();//这个私有类这里不可以访问

(new Test()).new ProtectedTest3().publciTest();//这个保护类这里可以访问,公有方法可以访问

(new Test()).new ProtectedTest3().privateTest();//这个保护类这里可以访问，私有方法不可以访问

(new Test()).new ProtectedTest3().protectedTest();//这个保护类这里可以访问，保护方法可以访问

(new Test()).new ProtectedTest3().defaultTest();//这个保护类这里可以访问，默认访问权限方法可以访问

(new Test()).new DefaultTest3().publciTest();//这个默认访问权限类这里可以访问，公有方法可以访问

(new Test()).new DefaultTest3().privateTest();//这个默认访问权限类这里可以访问，私有方法不可以访问

(new Test()).new DefaultTest3().protectedTest();//这个默认访问权限类这里可以访问，保护方法可以访问

(new Test()).new DefaultTest3().defaultTest();//这个默认访问权限类这里可以访问，默认访问权限方法可以访问

(new Test()).new PublicTest3().publciTest();//这个公有类这里可以访问,公有方法可以访问

(new Test()).new PublicTest3().privateTest();//这个公有类这里可以访问,私有方法不可以访问

(new Test()).new PublicTest3().protectedTest();//这个公有类这里可以访问,保护方法可以访问

(new Test()).new PublicTest3().defaultTest();//这个公有类这里可以访问,默认访问权限方法可以访问

}

}

测试子类的情况：

package Lianxi.yong2;

import Lianxi.yong.Test;

import Lianxi.yong.Test.DefaultTest3;

import Lianxi.yong.Test.ProtectedTest3;

import Lianxi.yong.Test.PublicTest3;

import Lianxi.yong.Test.privateTest3;

public class SubTest extends Test {

public void test(){

new privateTest3().publciTest();//这个私有类这里不可以访问

new privateTest3().privateTest();//这个私有类这里不可以访问

new privateTest3().protectedTest();//这个私有类这里不可以访问

new privateTest3().defaultTest();//这个私有类这里不可以访问

new ProtectedTest3().publciTest();//这个保护类这里可以访问,公有方法可以访问

new ProtectedTest3().privateTest();//这个保护类这里可以访问,私有方法不可以访问

new ProtectedTest3().protectedTest();//这个保护类这里可以访问,保护方法不可以访问

new ProtectedTest3().defaultTest();//这个保护类这里可以访问,默认访问权限方法不可以访问

new DefaultTest3().publciTest();//这个默认访问权限类这里不可以访问

new DefaultTest3().privateTest();//这个默认访问权限类这里不可以访问

new DefaultTest3().protectedTest();//这个默认访问权限类这里不可以访问

new DefaultTest3().defaultTest();//这个默认访问权限类这里不可以访问

new PublicTest3().publciTest();//这个公有类这里可以访问,公有方法可以访问

new PublicTest3().privateTest();//这个公有类这里可以访问,私有方法不可以访问

new PublicTest3().protectedTest();//这个公有类这里可以访问,保护方法不可以访问

new PublicTest3().defaultTest();//这个公有类这里可以访问,默认访问权限方法不可以访问

}

}

内部类相当于外部类的一个属性，所以一般的访问权限的规则都适合于内部类，而且内部类的方法相当于外部类的方法来对待，如果内部类的访问权限是protected，则内部类中的方法的访问权限也是protected,这也是为什么

protected class ProtectedTest3{//内部类是可以声明为私有的

    public ProtectedTest3(){}//要想要子类访问，这里必须把构造方法设置为public

    public void publciTest(){}

    private void privateTest(){}

    protected void protectedTest(){}

    void defaultTest(){}

}

ProtectedTest3的构造方法访问权限是protected，跟内部类的访问权限一样，所以需要写明是public

java里的public int doStuff(int factor)是什么意思？

public int doStuff(int factor){}是java中定义方法的语法，public 是访问控制修饰符

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

public : 对所有类可见。使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

int表示返回值类型，通常可以是任意类型，如果无返回值则为void

doStuff则是方法名，这个是自定义的，张三李四都无所谓，你乐意叫啥都行，但是通常建议为识名达意，一看就知道你这个方法是干嘛的

圆括号里面则为参数，参数可以有多个，基本格式为 数据类型 空格 参数名，同理，类型可以是任意类型，参数名可以任起

希望我这么说你能看懂

JAVA里面的包，公共类和方法有什么区别

1、public：对所有用户开放，所有用户都可直接调用

2、private：私有。除了class自己之外，任何人都不可直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可使用。

3、protected：对于子女、朋友来说，就是public的，可自由使用，无任何限制；而对于其他的外部class，protected就变成private。（同一个包中的类，若不在同一个包中，必须为其子孙类才可使用）

4、默认：默认可以称为friendly，但是java语言中是没有friendly这个修饰符的，这样称呼应该是来源于c++。默认的访问权限是包级访问权限。

作用域 当前类 同一package 子孙类 其他package

public √ √ √ √

protected √ √ √ ×

default √ √ × ×

private √ × × ×

JAVA中public static void main(string[]args)中的(string[]args)是什么意思

String args[]的意思是用于接收用户输入的参数，如果程序中需要用户输入参数。那么这些参数就保存在数据args中。操作方法如下：

1、首先可以使用String类的toCharArray() 方法进行转换，代码如下。

2、上个步骤中的String的长度不为1的，如果是单个字符转为String，代码如下。

3、char类型 转 String 类型，即可利用String构造方式，代码如下。

4、char转为String类型，也可以通过StringBuffer类完成，代码如下。

5、最后如下图所示，就完成了。

java公共方法的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java公共方法说明文档生成、java公共方法的信息别忘了在本站进行查找喔。