（1.10）java基础语法自述–类和对象篇–（传参,包，访问修饰符，类属性）

一，传参

• 变量有两种类型，基本类型和类类型
• 参数也是变量，所以传参分为，基本类型传参，类类型传参

1. 基本类型传参

• 在方法内，无法修改方法外的基本类型参数

public class Books{
   String name;
   int page;
   
   public void addpage(int pages){
       page = page+pages;
       pages = 0;//增加页数完后将增加的页数归零。
   }
   public Books(String name ,int page){
       this.name= name;
       this.page = page;
   }
   public static void main(String[] args){
       Books h = new Books("三体",312);
       int pages = 100;//增加页数为100
       h.addpage(pages);
       System.out.println(h.page);
   }
}

2. 引用与=

• 如果一个变量是基本类型，如 int h = 5; 我们管h就叫变量，=表示赋值的意思
• 如果一个变量是类类型，如Books h1 = new Books(); 我们就管h1叫引用，= 表示指向的意思，所以连起来就叫，引用h1，指向一个Books对象

3. 类类型传参

• 类类型也叫做引用

public class Books{
    String name;
    int page;
    public Books(String name, int page){
        this.name = name;
        this.page = page;
    }
    //设计读了多少页，和其他额外的页数。
    public void reading(Books h,int pages){//引用h
        h.page = h.page + pages;
    }
    public static void main(String[] args){
        Books h1 = new Books("三体1",312);
        Books h2 = new Books("三体2",334);
        h2.reading(h1,100);//引用h1，不同于之前h的引用，这样可以使得两个引用指向同一个对象。
        System.out.println(h1.page);
    }
}

二，包，package

1.把比较接近的类，规划在同一个包下

• 在最开始的地方，声明该类所处于的包名。

package Item;//在最开始的地方声明；
public class Books{
    String name;
}

2. 使用其他包下的类，必须要用import

• 在同一个包下的其他类，可以直接使用，但要是在不同包下的类，必须要用其他类。

package charactor;
//Books类在其他包里，需要用import引用
import Item.Books;

public class hhh(){
    int age;
    public void reading(Books h){        
    }
}

三，访问修饰符

• 成员变量有四种修饰符，private, public , protected, package/friendly/default 不写

1. 类之间的关系

1. 自身：指的是Books自己。
2. 同包子类： 同包下，且有继承关系
3. 不同包子类：在不同包，但有继承关系
4. 同包类: 与同包子类不同，它们没有继承关系
5. 其他类；在不同包，也没有继承关系

2.private 私有的

• 使用private修饰属性
  • 自身：是可以访问的
  • 同包子类，不同包子类：不可继承
  • 同包类，其他类：不可访问

public class Books{
    //属性name是private的，只有Books自己可以访问
    //子类不可继承
    //其他类也不可访问
    private String name;
}

3.package/friendly/default 不写

• 没有修饰符即代表，是package/friendly/default修饰的，只是它没写出来…

public class Books{
    private String id;
    
    //无修饰符的属性page；自己可以访问；
    //同包子类可以继承，不同包不能继承；
    //同包类可以访问，其他类不能访问；
    int page;
}

4. protected 受保护的

• 受保护的修饰符

5. public 公共的

• 公共的修饰符，任何地方均可访问。

6.总结

	自身	同包子类	不同包子类	同包类	其他类
private	可访问	不可继承	不可继承	不可访问	不可访问
package	可访问	可继承	不可继承	可访问	不可访问
protected	可访问	可继承	可继承	可访问	不可访问
product	可访问	可继承	可继承	可访问	可访问

7.各种修饰符的的使用场景

1. 属性通常使用private封装起来；
2. 方法一般用public用于被调用；
3. 会被子类继承的方法，通常使用protected；
4. package用的不多；

• 作用范围最小原则
  • 能用private就用private，不行就升一级用package，再不行就protected，最后用public
  • 这样能把数据尽量分封装起来，没有必要放出来的，就不用放出来了；

四，类属性

1. 类属性与对象属性

• 类属性：又叫做静态属性，即当一个属性被static修饰时

• 对象属性：又叫做实例属性，非静态属性

• 总结：如果一个属性被声明成类属性，那么所有的对象都共享这么一个值；

• 与对象属性不同，不同的对象的对象属性都可能

2. 访问类属性

• 访问类属性有两种方式

1. 对象.类属性

2. 类.类属性

   public class Books{
       String name;     //实例属性，对象属性，非静态属性
       static int page; //类属性，静态属性
       public static void main(String[] args){
           Books h = new Books();
           h.name = "三体";//对象.属性
           Books.page = 312; //类.类属性
           				  //类属性一旦申明，后面的对象都可以共享这个值
           System.out.println(h.name);
           System.out.println(h.page);
           
          	Books h1 = new Books();
           h1.name = "假如生活欺骗了你";
           System.out.println(h1.name);
           System.out.println(h1.page);//此处共用了前面类属性申明的值
       }
   }
   

3. 什么时候使用对象属性，什么时候使用类属性？

1. 如果一个属性，每个对象都是不一样的，这样的属性就应该设为对象属性，因为它是跟着对象走的。
2. 如果一个属性，所有对象都共享，都是一样的，那么就应该设为类属性（废话…)。