java视频学习路径（java面向对象）java封装

1、封装的概念和特点

1、什么是封装？封装就是将类的某些信息隐藏在类的内部，不允许外部程序直接访问。只能通过该类提供的方法来实现对隐藏信息的操作和访问。

2、简单的说就是：隐藏对象的信息，留出访问的接口。

3、你可能会疑惑，又想隐藏信息，又想让别人访问，你想干嘛？那么你可以想一下ATM机，对于ATM机来说就是个类。现金就是ATM机的重要信息，这种信息能直接让你看到么？能直接让你拿走么？那全国人民都有钱了。但是ATM的钱还是可以被拿走，因为ATM机上有卡的插口，就是留出的接口，只要你有卡，你有密码，你就能取出钱。

4、封装的特点：只能通过规定的方法去访问数据。

2、封装的代码实现

1、实现对代码封装步骤：

（1）修改属性的可见性：设为private。

（2）创建getter/setter方法：设为public，用语属性的读写。

（3）在getter/setter方法中加入属性控制语句：对属性的合法性进行判断。

2、举例实现上述封装的步骤

package com.imooc;

public class Cat {
	//成员属性
	private String name;          
	private int month;            
	private double weight;      
	private String species;   
	
	public Cat() {
		System.out.println("no parameter constructor");
	}
	
	public void setName(String name) {
		this.name=name;
	}
     public String getName() {
		return "the name of this cat is:"+this.name;
	}
	
}

3、在使用的时候，我们就只能通过使用setName和getName这两个正规的方法去实现对对象名字的读写功能。

public static void main(String[] args) {
	Cat cat=new Cat();
	cat.setName("fanfan");
	System.out.println(cat.getName());
}

4、属性的读写，我们也可以通过快捷的方式去生成get和set方法，在空白的区域点击右键，在source中选择Generate getters and settters，这样就能快捷的设置所有私有属性的读写方法。

5、我们使用带参构造函数的时候，最好在构造函数中使用属性的getters和setters方法去赋值。最好不要在构造函数中直接给私有属性赋值

3、使用包进行类管理

1、java中使用包去管理文件和解决同名文件冲突。

2、java中一个包里不能存在同名类。同名类只能在不同的包当中。

3、java中包的命名一般是域名倒序+模块+功能。全部小写。

3.1、接下来我们说说如何使用跨包的类调用?有几种调用形式？

package com.imooc.test; //定义包
//第一种方法：导入包(加载com.imooc这个包下面的所有类)
import com.imooc.*;

//第二种方法：通过导入包名.类名去导入指定包中的指定类
import com.imooc.Cat;

//第三种方法：直接在使用的过程中加载指定包中的指定类
com.imooc.CatTest tex=new com.imooc.CatTest();

3.2、导入不同包中的同名类

1、首先最容易错误的就是下面这种写法：不能通过包名.类名的方式去导入不同包中的同名类。

import com.imooc.mechanics.Cat;
import com.imooc.Cat;

2、我们通常的做法是这样的：一种用包.类名的方式，一种用包.*的方式，如下图:

import com.imooc.mechanics.Cat;
import com.imooc.*;

使用的时候不过就是麻烦了一点，直接导入Cat的类名的Cat类直接用，另一个要使用com.imooc.Cat来表示。

3.3常用的系统包

（1）java.lang：包含java语言的基础的类，这个包系统加载的时候会默认导入。

（2）java.util：包含java诞中的常用工具，如Scanner、Random。

（3）java.io：包含输入输出功能的类，如InputStream、File。

4、static关键字

1、static表示静态的，使用static修饰的成员属性都是静态成员，类成员。换句话说，所有实例化的对象都共用同一块静态空间。

2、static修饰的属性的特点：类对象共享，和类同生共死；

3、静态的访问方法：使用{ 类名.静态属性名 }的结构,比如说Cat.price。

4、使用static去修饰方法，方法就变成了一个静态方法，可以通过对象去访问，也能通过类名去访问。但是更推荐的是静态访问方法。

5、不存在静态的类，也就是static不能修饰类。也不存在static+方法内的局部变量。

6、静态方法不能直接访问同一个类中的非静态方法和非静态属性。共享东西里面怎么能使用个人的东西的呢？

5、代码块

1、普通代码块是顺序执行，先出现，先执行。

2、构造代码块：创建对象时调用，优先于构造方法执行。构造代码块的写法是将代码用{}包裹就行了：

{
    name="fanfan"; //构造代码块可以在其中对普通的属性赋值
    System.out.println("我是构造代码块")
}

3、构造代码块也可以有多个，按照顺序执行。

4、静态代码块：类加载的时候调用，优先于构造代码块执行。写法就是用static来修饰构造代码块：

static{
    price=150;//静态代码块中只能对static修饰的属性进行赋值，除非你这里实例化对象，通过对象去访问普通属性
    Cat temp=new Cat();
    temp.name="fanfan";
    System.out.println("我是静态代码块");
}

5、静态代码块也是可以有多个，按照顺序执行。

6、特别注意：静态代码块无论你实例化多少个对象，都只执行一次，而构造代码块每实例化一个对象都会执行一次。

7、使用代码块的好处是在同一方法中可以使用两个同名变量：

public Cat() {
    //int temp=10;
	{
		int temp=12;
		System.out.println(temp);  //12
	}
    //int temp=15;
	System.out.println("no parameter constructor"+temp); //temp不存在，报错
	{
		int temp=16;
		System.out.println(temp);  //16
	}
}

8、但是要要注意，在java中，我们把上面的代码中最上面的注释int temp=10的注释去掉，后面打印出来的temp全是10，因为temp的生存周期存在整个Cat函数，而且int temp=12和int temp=16都算是重复定义，会报错。

9、我们把中间的int temp=15的注释去掉，那么int temp=12不会报错，因为12的temp生命周期到代码块结束的 } 就结束了，但是下面的int temp=16，就是重复定义，因为15的temp的声明周期中包含了16的temp，所以16的temp属于重复定义。