本文目录一览：
- 1、java如何设置文件的权限
- 2、java中public，private，protected和默认的区别，最好形象一点，举几个例子
- 3、private在Java中是什么意思？
- 4、java 的class 为什么不可以是protected访问权限
- 5、java定义了几个关键字用于表示几种访问权限？各表示什么含义？
- 6、Java中子类的访问权限为何比父类大？
java如何设置文件的权限
在Java中，文件权限是非常具体的操作系统：* nix中，NTFS（Windows）及FAT/FAT32，都有着别样的文件权限。 Java提供了一些通用的文件权限来处理它。
检查文件权限允许：
1.file.canExecute(); – 返回true，文件是可执行的，false 则不是。
2.file.canWrite(); – 返回true，文件是可写的，false 则不是。
3.file.canRead(); – 返回true，文件是可读的，false 则不是。
设置文件权限：
1.file.setExecutable(boolean); – true允许执行操作; false则是禁止它。
2.file.setReadable(boolean); – true允许读操作; false则是禁止它。
3.file.setWritable(boolean); – true允许写操作; false则是禁止它。
在* nix的系统中，可能需要配置有关文件权限的详细指定，例如设置777权限的文件或目录，但是，Java的IO类没有现成的方法，但你可以使用下面的解决方法：
Runtime.getRuntime().exec("chmod 777 file");文件权限的例子
import java.io.File;
import java.io.IOException;
/×
×只能给当前用户赋予对该文件的权限，调用createNewFile（）方法默认的权限是644.
×/
public class FilePermission
{
public static void main( String[] args )
{
try {
File file = new File("/home/test3.txt");
if (file.createNewFile()){
System.out.println("File is created!");
//Runtime.getRuntime().exec("chmod 777 /home/test3.txt");
file.setExecutable(true);//设置可执行权限
file.setReadable(true);//设置可读权限
file.setWritable(true);//设置可写权限
System.out.println("is execute allow : " + file.canExecute());
System.out.println("is read allow : " + file.canRead());
System.out.println("is write allow : " + file.canWrite());
}else{
System.out.println("File already exists.");
}
} catch (IOException e) {
e.printStackTrace();
}
}
java中public，private，protected和默认的区别，最好形象一点，举几个例子
1、private修饰词，表示成员是私有的，只有自身可以访问；
2、protected，表示受保护权限，体现在继承，即子类可以访问父类受保护成员，同时相同包内的其他类也可以访问protected成员。
3、无修饰词（默认），表示包访问权限（friendly， java语言中是没有friendly这个修饰符的，这样称呼应该是来源于c++ ），同一个包内可以访问，访问权限是包级访问权限；
4、public修饰词，表示成员是公开的，所有其他类都可以访问；
private在Java中是什么意思？
Private ，编程语句在模块级别中使用，用于声明私有变量及分配存储空间。
private
读法：英 [ˈpraɪvət] 美 [ˈpraɪvət]
1、adj. 私人的，私有的；私立的；私营的
2、adj. 私下的，不公开的，秘密的
3、adj. （场所）清静的；（人）不愿吐露心思的，内向的
4、adj. 无官职的
5、n. 列兵；二等兵
短语
1、Private Life 个人生活 ; 私生活 ; 私人生活 ; 香港小姐写真
2、Private placement 私募 ; 私募配售 ; 私募融资
3、Private Secretary 私人秘书 ; 私家秘书 ; 私家文秘 ; 小我私家秘书
4、private cloud 私有云 ; 私密之云
5、private key 私钥 ; 私密金钥 ; 私有密钥 ; 私人密钥
扩展资料
private近义词：chamber
读法：英 [ˈtʃeɪmbə(r)] 美 [ˈtʃeɪmbər]
1、n. （身体或器官内的）室，膛；房间；会所
2、adj. 室内的；私人的，秘密的
3、vt. 把…关在室内；装填（弹药等）
短语
1、chamber pot 马桶 ; 便壶 ; 夜壶 ; 便桶
2、magma chamber [地物] 岩浆房 ; 岩浆储源 ; 岩浆库 ; 熔岩领地
3、air chamber 气室 ; [建] 空气室 ; 气腔 ; 空气包
4、echo chamber 回响室 ; 回音室 ; [声] 回声室 ; 回声室效应
5、cooling chamber 冷冻箱 ; 冷却室 ; 冷却腔
java 的class 为什么不可以是protected访问权限
1. protected 访问控制符能被用于方法和成员变量。
2. 声明为protected的方法和成员变量能被同一个包里的所有类所访问，就像默认修饰符package一样。
3. 能被该类的子类所访问，子类可以和父类不在一个包中。
这样，当你想让一个类中的某个方法或成员变量在包中都可见，而且其子类也能访问（子类有可能和父类不在同一个包中）但又不想让所有类都可以访问该类时，就可以用protected修饰符。
可访问性： public protected package private
注意：
4. But a subclass in another package can access the protected members in the super-class via only the references of subclass or its subclasses. A subclass in the same package doesn’t have this restriction. This ensures that classes from other packages are accessing only the members that are part of their inheritance hierarchy.
但是位于与父类不同包中的一个子类，能够使用其父类中protected成员的途径只能是，使用子类（或者是子类的子类）的引用。子类和父类在同一个包中则没有这个限制。这样就保证了其他包中的类只能访问它们所继承的部分成员。
下面的例子可以说明上述几点：（特别注意第4点）
1 创建一个父类Bird.java，放在birdpack包中，父类中有一个protected int的成员变量nFeathers：
package birdpack; public class Bird { protected int nFeathers; }
2 创建Bird的一个子类Duck1.java，放在duckpack包中，这个程序说明在子类中直接使用父类的protected变量是可以的，父类的protected权限的成员变量可以被子类继承：
package duckpack; import birdpack.Bird; public class Duck1 extends Bird { public void setn(int duck1n) { nFeathers = duck1n; } }
3 创建Bird的一个子类Duck2.java，放在duckpack包中，这个程序说明在子类中通过子类的对象访问父类的protected成员是可以的：
package duckpack; import birdpack.Bird; public class Duck2 extends Bird { public void constructor(int newDuck2) { Duck2 d2 = new Duck2(); //在子类中通过子类的对象访问父类中的protected变量 d2.nFeathers = newDuck2; } }
4 创建Bird的一个子类Duck3.java，放在duckpack包中，这个程序说明在子类中使用父类的对象访问父类的protected成员反而是不行的：
package duckpack; import birdpack.Bird; public class Duck3 extends Bird { public void constructor(int newDuck3) { Bird b = new Bird(); //子类中用父类对象反而不能访问父类中的protected变量 //b.nFeathers = newDuck3; } }
5 创建Bird的一个子类Swan.java，放在duckpack包中，这个程序说明在子类中使用其他子类的对象访问父类的protected成员也是不行的：
package duckpack; import birdpack.Bird; public class Swan extends Bird { public void constructor(int swan) { Duck1 d1 = new Duck1(); //子类中用另外一个子类的对象也不能访问父类中的protected变量 //d1.nFeathers = swan; } }
-------------------------------------------------------------------------------------------------------------------------------
转载这篇文章，主要是为了说明，虽然在java中，父类中protected权限的成员变量可以被子类访问，但是还是有条件的，具体如下：
1.在子类中直接使用父类的protected变量是可以的，父类的protected权限的成员变量可以被子类继承
2.在子类中通过子类的对象访问父类的protected成员是可以的
3.在子类中使用父类的对象访问父类的protected成员反而是不行的
4.在子类中使用其他子类的对象访问父类的protected成员也是不行的
java定义了几个关键字用于表示几种访问权限？各表示什么含义？
还有两天,由于时间关系,尽量帮你答哈,呵呵你也太小气了吧,5分不如不给呵呵开个玩笑
1.不存在的,基本单位:类
2.一般是从main()方法开始的
3.构造函数在类创建对像时无条件调用,而一般方法则要要对像去才可以调用,当然static方法直接用类名也可以调用
4.print()或println()两个方法,如System.out.println();
5.和你主类名必需完全相同,注意大小写,也就是public类的类名
6.javac 文件名.java
7.是.class文件
8.java 文件名(没有.java)
9.
public class HelloWorld{
public static void main(String]
args){
System.out.println("Helloworld");
}
}
第二部分:
1.标识符就是用户自己启的名字,有类名,方法名,变量名,要求:1.区分大小写,2.不能以数字开头3.不能要关键字
顺便说一哈在java中 还有一个不成文的约定那就是:类名可以用若干个单词组合起来,第个单词的第一个字母要大小,变量名一般用小写,方法名的第一个字母用小写,常量名全用大写,可用下划线___分开
2.
有六个:byte(1) short(2) int(4) long(8) float(4) double(8) 括号里表示其占的字节数
3.类和方法的前面不加关键字,编译器会给它一个默认的关键字default或friendly表示在同一个包在可以访问它.
4.不是很清,不过你可以用StringBuffer类的append()方法追加
5.这两个都是一个位移运算符,都表示右移一位,不同的是""若被移动的数为正数,则最左填为0,否则填为1,而""不管正数负数最左为0,(请注意:这都是在二进制的情况下进行的,了解一下就行了,用得不多)
6.
public class Max{
static int max=0,min=0;
static void swap(int a,int b,int c){
max=ab?a:b;
max=maxc?max:c;
min=ab?a:b;
min=cmin?c:min;
System.out.println(a+" "+b+" "+c+"这三个数的最大值是:"+max);
System.out.println("最小的数是:"+min);
}
public static void main(String[] args){
swap(-1,0,1);//你可以在这里改变它的参数,比较别的数
}
}
7.
public class Factorial{
public static void main(String[] args){
int factorial=10;
for(int i=factorial-1;i0;i--){
factorial=factorial*i;
}
System.out.println("10!="+factorial);
}
}
8.
public class EatPeach
{
public static void main(String[] args)
{
int n=1;
for(int i=10;i0;i--)
{
System.out.println("第"+i+"天吃了"+n+"个桃子");
n=(n+1)*2;
}
}
}
第三部分:
1.类就是整个java程序执行的模块,由成员变量和成员方法(也叫函数)组成
2.修饰符你说的是关键字吧:
public(共用访问符,无能什么地方都可以访问),
private 只能同一个包可以访问
protected 允许子类继承并修改
static 静态存偖区,在程序执行完后才释放内存
final 常量,不能改改的量
主要的就是这几个,当然你的题议还有int double long boolean float 等等这些你应该知道的就不用说了
3.类的构造函数将会在创建类的对像的第一时间得到调用,而普通方法要用对像才能调用,(当然如果是static方法的话也可以用类然直接调用)
4.Math类和Random类
5.
public(共用访问符,无能什么地方都可以访问),
private 只能同一个包可以访问
protected 允许子类继承并修改
final 用在类的前面不能继承它
6.静太成员一般是在程序执行完后才释放内存,反之则是在当前方法完毕就释放,而main就是这个性质来的,要加static
7.抽像类是不能完成某个具体的动作的,也就是一个接口,(注意只要有一个抽像方法在内的类必定定义为抽像类)
非抽像类刚刚相反
8.抽像方法没有方法体,如abstract void f();非抽像方法有方法体如void f(){}
9..(最终类，最终方法，最终属性就是在类,方法和变量的前加final)
含义就是:当放在类前,降低了此类的访问权限,重要的是别的类不能继承它
当放在方法前:表示这个方法不可以修改,更不得覆盖它
当放到变量前:也就是我们讲的常量,你一定晓得是不变的量,这我就不用多说了
10.
class Employee{
private String name;
private int salary,hireDay;
Employee(String name,int salary,int hireDay){
this.name=name;
this.salary=salary;
this.hireDay=hireDay;
}
public String getName(){
return name;
}
public int getSalary(){
return salary;
}
public int getHireDay(){
return hireDay;
}
}
//注:你说的三个私有方法用一个构造器完成要简单一些,如果你一定要那么做,只要把三个参数改成//三个方法就可以了
//11.
public class EmployeeTest{
public static void main(String[] args){
Employee[] e={
new Employee("小明",800,10),
new Employee("小强",600,15),
new Employee("小华",900,12)
};
System.out.println("name "+" salary"+" hireDay");
for(int i=0;ie.length;i++)
System.out.println(e[i].getName()+" "+e[i].getSalary()+
" "+e[i].getHireDay());
}
}
注意你要先编译第一个，第二个才能运行
第四部分:
1.这个题不是很好,意思不够明确,这里我说两种吧多态和覆盖都是继承.当然接口也可以继承,所以我说这个题出得不好!
2.当我们使用关键字extends时就表示一个类继承了另一个类,也就是子类和父类,对于方法来说有下面三种:
(1).方法继承,在子类中不需定义就拥有的父类在的方法
(2).方法的覆盖:是指返回的类型,形式参数和方法名都相同,改变其方法体.
(3).方法的重载:则是方法名相同,形式参数不同的几个方法,如:洗车,洗衣服,有一个是相同的,就是洗这个属性(方法名),不同的是车,衣服(参数),所以我们不必这样说(用洗车的方法来洗车,用洗衣服的方法来洗衣服)就能分开洗车是做什么和洗衣服是做什么,正是如此编译器是通过这种方式来识别调用哪个方法的
(4.abstract class Employee{
abstract int getSalary();
}
class CommonEmployee extends Employee{
private int salary;
CommonEmployee(int salary){
this.salary=salary;
}
public int getSalary(){
return salary;
}
}
class Manager extends Employee{
private int salary;
Manager(int salary){
this.salary=salary;
}
public int getSalary(){
return salary;
}
}
public class SimpleTest1{
public static void main(String[] args){
Employee com=new CommonEmployee(1200);
Employee man=new Manager(2000);
System.out.println("职工的工次是:"+com.getSalary());
System.out.println("经理的工资是:"+man.getSalary());
}
}
5.java的多态性是指:许多类它们有一个共同的特点,我们如果每个特征我们都去写的话会用很多的代码也很麻烦,那么解决这一问题的正是多态性,
那如何解决呢??我们可以把这些相同的特点写成一个接口或抽像类,然后只要有这个特征的类继承它就可以了,其中有一个很经典的例子:画图,我们可以创建一个图形的抽像类,因为三角形啊,正方形啊,都是图形,于是可以继承这个类,于是我们可以用这些图形来继承上面所创建的图形类,如果你不是很理解的话我把这个例子写到下面你仔细看就会明白的:
import java.util.*;
class Shape{
void draw(){}
void erase(){}
}
class Circle extends Shape{
void draw(){
System.out.println("Circle.draw()");
}
void erase(){
System.out.println("Circle.erase");
}
}
class Square extends Shape{
void draw(){
System.out.println("Square.draw()");
}
void erase(){
System.out.println("Square.erase()");
}
}
class Triangle extends Shape{
void draw(){
System.out.println("Triangle.draw()");
}
void erase(){
System.out.println("Triangle.erase()");
}
}
//和以上是组合的关系
class RandomShapeGenerator{
private Random rand=new Random();
public Shape next(){//反回一个对像
switch(rand.nextInt(3)){
default:
case 0:return new Circle();
case 1:return new Square();
case 2:return new Triangle();
}
}
}
public class Shapes{
private static RandomShapeGenerator gen=
new RandomShapeGenerator();
public static void main(String[] args){
Shape[] s=new Shape[9];
for(int i=0;is.length;i++)
s[i]=gen.next();//给引用填对像
for(int i=0;is.length;i++)
s[i].draw();//能过动态帮定调用哪一个方法
}
}
如果还是看不会的话,那么请你打开书好好看抽像类,然后再看看接口,你不会看不懂的,去试试!!!!
6.this和super有一个最易理解的就是this表示当前对像,super表示可以引用父类中的构造函数,
当然它们的功能远远不止这些!这我就不多说了
7.
如果把子类的对像转化为父类中的对像,我们称为向上转型,一般这个好实现也很重要,用得也多,可以创建一个子类对像,然后传给父类的引用,这种说法我不知道科不科学,也很不好理解,但事实就是如此,如上面的图形例子中:
Shape next={ new Circle(),
new Square(),
new Triangle()
};
这看起来每个类的对像都给了同一个父类(Shape),这有一个问题它们表示同一对像吗?你看以把它们看成同一引用,然后事不是你想的这样,next[1].draw(),next[1].draw(),next[2].draw()它们调的并不是同一个方法,而分别调用的是Circle Square Triangle的中的draw()方法,你可以亲自运行上面的事例就知道了,好了有点说得多了,如果有问题的话加我QQ吧460566995
8.默认构造函数是指在我们没有构造函数时编译器自动帮我们加上一个构造函数一般为:类(){},它没有任何参数,也没有方法体
好了,我手都写软了,就给你答这么多吧,还有没有答完的希望后者能补上谢谢,我这两天也没有时间了,
如果没有人答你又一定要要的话可以加我的QQ问我好了,好好看里面有我的QQ的
Java中子类的访问权限为何比父类大？
因为 向上转型及java程序设计维护的原因
例:
假设一个父类A 拥有的方法 public void setXXX(){} 可以被其他任意对象调用
这个方法被子类B 覆写后 为 void setXXX(){} 即 默认的 访问权限 只能被本包极其子类 所访问
假设 其他包中的对象 C 调用 方法为：
get( A a){
a.setXXX();
}
而此时传入的对象为B类对象，假设为b此时b将转型为a但是b中的setXXX() 调用权限
已经被缩小了这将造成错误。所以子类对象不能比父类对象访问权限大
以上只是一个例子还有其他出于易维护、易代码结构设计的设计思想原因
