Java進階總結——訪問權限
Java進階總結3
1.訪問權限控制符
/**
* 訪問權限控制符
* 控制符 修飾 範圍
* private 字段、方法 本類
* 默認 字段、方法、類 同包
* protected 字段、方法 同包、不同包
* public 字段、方法、類 同包、不同包
* */
1.1測試private權限修飾符
package day08;
public class FirstDemo {
//屬性
private String name;
//方法
private void study(){
System.out.println(name+"Hello");
}
public static void main(String[] args) {
// TODO 自動生成的方法存根
FirstDemo demo=new FirstDemo();
demo.name="尊";
demo.study();
}
}
//測試pricate修飾符
class FirstDemo1{
public void method() {
FirstDemo demo1=new FirstDemo();
//demo1.name="安娜";
}
}
輸出結果：
1.2測試默認權限修飾符
package day08;
public class SecondDemo {
String like;
void toEat(){
System.out.println("大餐");
}
}
//默認訪問權限修飾符
class SecondDemo1{
}
package day08;
//在同包中不需要import引用
public class TestDemo {
public static void main(String[]args) {
//測試默認權限修飾符
SecondDemo demo=new SecondDemo();
demo.like="寫作";
demo.toEat();
//4.初始化一個默認權限修飾的類
SecondDemo1 demo1=new SecondDemo1();
System.out.println(demo1.toString());
}
}
輸出結果:
1.3測試public權限修飾符
package day08;
public class ThirdDemo {
//屬性
public String name;
public int age;
//方法
public void printFormat() {
System.out.println(name+"\t"+age);
}
}package day08.test;
import day08.SecondDemo;
import day08.ThirdDemo;
public class TestDemo {
/**
* 不同包測試不同的類
* */
public static void main(String[]args) {
//1.初始化SecondDemo類
SecondDemo demo=new SecondDemo();
//2.訪問demo屬性
//demo.name="";//private 只能在同類中訪問
//demo.like="";//默認 只能在同包使用
//demo.toEat();//默認 只能在同包使用
//3.初始化一個默認修飾符的類
//SecondDemo1 demo1=new SecondDemo1();
//在不同包中訪問public 修飾的成員和類
ThirdDemo third=new ThirdDemo();
third.name="浪子一秋";
third.age=21;
third.printFormat();
}
}
package day08.test;
import day08.SecondDemo;
import day08.ThirdDemo;
public class TestDemo {
/**
* 不同包測試不同的類
* */
public static void main(String[]args) {
//1.初始化SecondDemo類
SecondDemo demo=new SecondDemo();
//2.訪問demo屬性
//demo.name="";//private 只能在同類中訪問
//demo.like="";//默認 只能在同包使用
//demo.toEat();//默認 只能在同包使用
//3.初始化一個默認修飾符的類
//SecondDemo1 demo1=new SecondDemo1();
//在不同包中訪問public 修飾的成員和類
ThirdDemo third=new ThirdDemo();
third.name="浪子一秋";
third.age=21;
third.printFormat();
}
}
輸出結果：
2. JavaBean
package day08;
/**
* JavaBean 是一種JAVA語言寫成的可重用組件(類).
* 1):類必須使用public修飾.
* 2):必須保證有公共無參數構造器,即使手動提供了帶參數的構造器,也得提供無參數構造器..
* 3):包含了屬性的操作手段(給屬性賦值,獲取屬性值).
* */
public class UserBean {
//字段
private String name;
private int age;
private boolean sex;
//公開方法
//getter方法: 僅僅用於獲取某一個字段存儲的值.
//去掉get,把首字母小寫,得到name1.此時name1纔是屬性.
public String getName() {
return name;
}
//setter方法: 僅僅用於給某一個字段設置需要存儲的值.
public void setName(String name1) {
//this主要存在於兩個位置:
//構造器中: 就表示當前創建的對象.
//方法中: 哪一個對象調用this所在的方法,那麼此時this就表示哪一個對象.
this.name = name1;
}
public int getAge() {
return age;
}
public void setAge(int age1) {
this.age = age1;
}
//如果操作的字段是boolean類型的,此時不應該叫做getter方法,
//而是is方法,把 getName 變成 isName.
public boolean isSex() {
return sex;
}
public void setSex(boolean sex) {
this.sex = sex;
}
//默認構造方法
}
package day08;
public class UserBeanTestDemo {
public static void main(String[] args) {
// TODO 自動生成的方法存根
UserBean user=new UserBean();
user.setName("浪子一秋");
user.setAge(21);
user.setSex(true);
System.out.println("姓名："+user.getName()+"年齡："+user.getAge()+"性別："+user.isSex());
}
}
輸出結果：
3.this
/*
* this 表示當前對象.
* this主要存在於1個位置:方法中
* 構造方法中: 就表示當前創建的對象.
* 實例方法中: 哪一個對象調用this所在的方法,那麼此時this就表示哪一個對象.
* 當一個對象創建之後,JVM會分配一個引用自身的引用:this.
*/
/*
* 使用this:
* ① 解決成員變量和參數(局部變量)之間的二義性,必須使用;
* ② 同類中實例方法間互調(此時可以省略this,但是不建議省略)。
* ③ 將this作爲參數傳遞給另一個方法;
* ④ 將this作爲方法的返回值(鏈式方法編程);
* ⑤ 構造器重載的互調，this([參數])必須寫在構造方法第一行;
* ⑥ static不能和this一起使用;
* 當字節碼被加載進JVM,static成員以及存在了.
* 但是此時對象還沒有創建,沒有對象,就沒有this.
*/
3.1this主要存在於方法中
package day08.thisdemo;
public class UserDemo {
//屬性
String name;
int age;
//方法
public void method() {
System.out.println("this==="+this);
//this.name="一葉知秋";
System.out.println(name+" "+age);
}
public static void method1() {
//this.name="name";
}
//默認構造方法
public UserDemo() {
this.name="劍俠情緣";
}
//入口方法
public static void main(String[]args) {
UserDemo.method1();
//初始化對象
UserDemo user=new UserDemo();
//user.name="尊";
user.age=21;
user.method();
System.out.println("user==="+user);
//初始化對象
UserDemo user1=new UserDemo();
user1.name="安娜";
user1.age=18;
user1.method();
System.out.println("user1==="+user1);
}
}
輸出結果：
3.2通過this 解決成員變量和局部變量的二義性
package day08.setinit;
public class User {
//屬性
private String name;
private int age;
//賦值 取值
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//默認構造方法
public User() {
}
public User(String name,int age) {
//通過this 解決成員變量和局部變量的二義性
this.name=name;
this.age=age;
}
public static void main(String[] args) {
// TODO 自動生成的方法存根
//初始化對象 賦值 兩種方式
//1. 通過setter注入
User user=new User();
user.setName("浪子一秋");
user.setAge(21);
System.out.println("name=="+user.getName()+"\nage=="+user.getAge());
//2.通過構造方法直接調用帶參數的構造器,創建出來的對象,就有了初始值.
User user1=new User("尊",20);
System.out.println("name=="+user1.getName()+"\nage=="+user1.getAge());
/**
*總結：
* 初始化對象的時候，對象的屬性比較少的情況下，我們通過構造方法給對象的屬性進行賦值
* 如果對象的屬性比較多的情況下，最好通過setter注入的方式進行賦值
*/
}
輸出結果：
3.3同類中實例方法間互調
package day08.thisdemo;
public class ThisDemo2 {
//同類中實例方法間互調(此時可以省略this,但是不建議省略)。
public void method1() {
System.out.println("唯我獨尊");
this.method2();//調用方法
}
public void method2() {
System.out.println("葬劍山莊");
this.method3();
}
public void method3() {
System.out.println("葬劍灬尊");
//this.method1();
}
public static void main(String[] args) {
// TODO 自動生成的方法存根
//初始化對象
ThisDemo2 demo2=new ThisDemo2();
demo2.method1();
}
}
輸出結果：
3.4將this作爲方法的返回值
package day08.thisdemo;
public class ThisDemo3 {
//將this作爲方法的返回值(鏈式方法編程);
public void method1() {
System.out.println("確認過的眼神");
}
//定義一個方法 有返回值
public ThisDemo3 method2() {
//處理一個操作
System.out.println("你不是對的人");
//將當前對象返回
return this;
}
public static void main(String[] args) {
// TODO 自動生成的方法存根
//初始化對象
ThisDemo3 demo3=new ThisDemo3();
System.out.println(demo3);
//ThisDemo3 demo32=demo3.method2();
//demo32.method1();
demo3.method2().method1();//鏈式語法編程
//System.out.println();
}
輸出結果：
3.5將this作爲參數傳遞給另一個方法
package day08.thisdemo;
public class ThisDemo4 {
//將this作爲參數傳遞給另一個方法;
//屬性
private String name;
static class Operation{
//接收一個對象 給對象的的name賦值
public static void setValues(ThisDemo4 demo4) {
demo4.setName("安娜");
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void method1() {
//獲取this 將this作爲參數 傳遞給另一個方法
Operation.setValues(this);
}
public static void main(String[] args) {
// TODO 自動生成的方法存根
//初始化對象
ThisDemo4 demo4=new ThisDemo4();
demo4.method1();
System.out.println(demo4.getName());
}
}
輸出結果：
3.6構造器重載的互調，this([參數])必須寫在構造方法第一行
package day08.thisdemo;
public class ThisDemo5 {
//構造器重載的互調，this([參數])必須寫在構造方法第一行;
//構造方法重載
//構造方法只有在對象初始化的時候纔會調用一次
//構造方法重載，構造方法也是每次只能顯示直接調用一個
public ThisDemo5() {
System.out.println("默認構造方法");
}
public ThisDemo5(String name) {
this();
System.out.println("1個參數的構造方法");
}
public ThisDemo5(String name,int age) {
this(name);//一個參數
System.out.println("2個參數的構造方法");
}
public static void main(String[] args) {
// TODO 自動生成的方法存根
//初始化對象
//ThisDemo5 demo5=new ThisDemo5();//調用默認的
//ThisDemo5 demo5=new ThisDemo5("尊");
ThisDemo5 demo5=new ThisDemo5("尊",21);
}
}
輸出結果：
4.綜合練習
package day08;
import java.util.Scanner;
class Point{
//屬性
private double x;
private double y;
public double getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}
class Distance{
public void distance(double r) {
//實例化對象
Point point =new Point();
//賦值
point.setX(-3);
point.setY(-4);
//計算兩點之間的距離
double d=Math.sqrt(point.getX()*point.getX()+point.getY()*point.getY());
//判斷點和圓的關係
if(d>r){
System.out.println("點在圓外");
}else if (d==r) {
System.out.println("點在圓上");
}else if(d<r){
System.out.println("點在圓內");
}
}
}
public class Circular {
public static void main(String[] args) {
// TODO 自動生成的方法存根
//Point point=new Point();
//初始化鍵盤錄入對象
Scanner in=new Scanner(System.in);
System.out.print("r==:");
double r=in.nextDouble();
//初始化對象
Distance dist=new Distance();
//調用方法進行判斷
dist.distance(r);
}
}
輸出結果：
5.知識框架