java基础知识整理(对象与引用,static关键字,包,访问权限修饰符)

对象与引用

引用类型:类,接口,数组.在java中除了基本类型之外都属于引用类型.

基本类型:8种,整数型(byte,short,int,long),浮点数(float,double),字符型(char),布尔值(boolean).

java中的对象是通过引用进行操作的.

//自定义一个类Dog
public class Dog {
String name;
String color;
float  price;
}
//创建一个对象
Dog mt = new Dog();
  /* 
   Dog mt = new Dog();
   new Dog() 以Dog类为模板,调用Dog类中的构造方法,在堆空间中创建Car类对象
   Dog mt 创建Dog类引用对象
   = 使对象引用指向刚创建的那个Dog对象
   Dog mt;
   mt= new Dog();
   可以看出有两个实体：一是对象引用变量，一是对象本身
 */

值传递与引用传递

在java中进行方法调用中传递参数时,有两种方式,引用传递和值传递.

值传递:

在方法调用时，实际参数把它的值传递给对应的形式参数，形式参数用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值

public class Zhi {
    /*值传递*/
    public static void main(String[] args) {
        int a = 10;
        Zhi z =new Zhi();
        z.Test(a);//基本数据类型,将值直接传递给其他的变量
        System.out.println("a="+a);
    }

    public void Test(int b){
        System.out.println("b="+b);
        b=5;
        System.out.println("b="+b);
    }
}

引用传递

方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数

public class Yin {
    /*引用传递*/
    public static void main(String[] args) {
        Yin y = new Yin();
        Dog d = new Dog();
        d.name="xxx";
        y.Test(d);//引用传递 传递的是对象的地址而不是对象本身
        System.out.println(d.name);
    }
    public void Test(Dog mt){
        System.out.println(mt.name);
        mt.name="hhh";
        System.out.println(mt.name);
    }
}

static关键字

static:静态的,可以修饰属性,方法,代码块,内部类.

被static修饰的成员,随着类的加载而加载,优先于对象存在,被所有对象共享,可以不用创建对象,直接被类调用.

public class Country {
    String name;
    int age;
/*
  static 静态的
  类变量  类只有一个  可以直接通过类调用
*/
    static String country="中国";
    
    public void testxiao(){
        System.out.println(name);
        System.out.println(country);//成员方法可以调用静态变量
    }
 //使用static修饰的方法  不能调用成员变量 类先于对象
    public static void  testXin(){
//        System.out.println(name); 报错
        System.out.println(country);
    }
}

 //static声明的 可以通过类名来进行调用
        Country.country="美国";
        Country arr = new Country();

模拟卖票

public class ShowTicket {
//票数是固定的 只有一份 声明为静态的
    static  int ticket=50;
    public static void testTicket(){
        ticket=ticket-1;
        System.out.println("电影票现有:"+ticket);
    }
    public static void main(String[] args) {
        ShowTicket.testTicket();
        ShowTicket.testTicket();
        ShowTicket.testTicket();
        ShowTicket.testTicket();
        ShowTicket.testTicket();
    }
}

代码块

代码块在类中声明，类似于一个没有名称的方法体，代码分实例块和静态块

   /*
    代码块 没有名称的一个方法体
    实例代码块 每次创建对象时自动调用
    */
    {
        System.out.println("实例代码块1");
    }
    {
        System.out.println("实例代码块2");
    }
    /* 静态代码块 
       类加载时自动调用 只调用一次*/
    static {
        System.out.println("静态代码块1");
    }
    static {
        System.out.println("静态代码块2");
    }

类的加载执行

public class Test {
    //类加载时  类中静态变量,静态方法被调用 仅一次
    static int num;//1
    int age;
    static{//1
        System.out.println("test static");
    }
    {//2
        System.out.println("test");
    }
    public Test() {//3
        System.out.println("test constructor");
    }
    public static void main(String[] args) {
        System.out.println(Test.num);
        new Test();
    }
}

包

包:package,包即是文件夹.

包的作用:

避免类重名

按照不同功能管理类(一般分为四级,第一级,该项目的类型,第二级项目所开发或者运行的公司,第三级项目名称,第四级项目模块化名称)

控制访问权限

/*
package 包
包就是文件夹
作用有:避免类重名
      可以按照不同功能管理类
      控制访问权限
包的命名 小写
        使用.来进行区分包的分级
*/
package feifan.day3;
/*
 在创建对象为其他包中的类时
 使用关键字 import+类的地址  将类的地址导进来
*/
import java.util.Date;
//import java.sql.Date; 不可  会造成混乱
/*
全类名 包名+类名的简称
*/
public class Damo {
    public static void main(String[] args) {

        Date a = new Date();

       java.sql.Date b = new java.sql.Date(6);//需要在前面加上类的地址
    }

}

访问权限修饰符

在java中有四种访问权限修饰符

1）public ：公共权限 修饰类、属性、方法。可以被任意类访问

2）protected：受保护的权限 修饰属性、方法。

​ 可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。

3）default：同包权限 修饰类、属性、方法。只能被同包的类访问

4）private：私有权限 修饰属性、方法。 只能在本类中访问

//同一个包
package feifan.day3;
//本类
public class DamoA {
    public int pub;
    protected  int pro;
    int def;
    private int pri;
    //公共权限
    public void pub(){
    }
    //受保护的权限
    protected  void pro(){

    }
    //默认权限/包权限
    void def(){

    }
    //私有权限
    private void pri(){

    }
    public void Test(){
        //在同一个类中 都可以访问
        DamoA a = new DamoA();
        System.out.println(a.pub);
        a.pub();

        System.out.println(a.pro);
        a.pro();

        System.out.println(a.def);
        a.def();

        System.out.println(a.pri);
        a.pri();
    }
}
//同一个包不同类
public class DamoB {
    public void test2(){
        DamoA b = new DamoA();
        //在同一个包不同类中 private 私有权限 无法访问
        b.def=1;
        b.def();
        b.pro=2;
        b.pro();
        b.pub=3;
        b.pub();

    }
}
//不同包中
package feifan.day4;

import feifan.day3.DamoA;

public class DamoC {
    public void test2(){
        DamoA c = new DamoA();
        //不同包不同类 公共权限可以访问
        c.pub=1;
        c.pub();
    }
}
//不同包
package feifan.day4;

import feifan.day3.DamoA;

public class  DamoD extends DamoA{
    public void test4(){
        DamoD c =new DamoD();
        //不同包的不同子类可以访问父类中受保护的成员
        c.pro=1;
        c.pro();
        c.pub=2;
        c.pub();
    }
}