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.知识框架