本文目錄一覽：
- 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() 調用權限
已經被縮小了這將造成錯誤。所以子類對象不能比父類對象訪問權限大
以上只是一個例子還有其他出於易維護、易代碼結構設計的設計思想原因
原創文章，作者：V4996，如若轉載，請註明出處：https://www.506064.com/zh-hant/n/129808.html
微信掃一掃 
支付寶掃一掃 