文章目录
一、封装
面向对象程序三大特性:封装、继承、多态。封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。将自身的对象属性隐藏起来，对外只通过接口和对象进行访问.
1.1如何封装？
封装是将对象的属性进行访问权限的控制，使不能进行直接访问.
class Person {
private String name;
private int age;
}
我们可以发现进行封装之后，我们不能轻易的去赋值。这样还有一个好处是我们不用去管属性名是否改变，而且通过一定的方法去赋值即访问。
对属性的访问权限设置为private，这样Person的属性只能在本类访问，信息的安全就有所保障了.
那如何访问这些封装的属性呢？
class Person {
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 static void main(String[] args) {
Person person = new Person();
person.setName("张三");
person.setAge(18);
System.out.println("name: "+person.getName()+" age: "+person.getAge());
}
1.2封装的优点
二、包的使用
2.1包是什么？
包是对类、接口等的封装机制的体现，是一种对类和接口等的很好的组织方式。
我们发现包实际是我们盘符中的一个文件夹，每一个类是文件夹里的一个文件。
那一个包中允许出现相同名称的类吗？
我们可以发现电脑无法在一个文件夹里命名两个相同的文件，所以一个包里不允许出现相同名称的类.
2.2如何导入包中的类
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
}
当我们想生成系统定义的对象或者访问方法时，因为系统限权的设置，我们直接访问就会出现下面的情况：
我们需要使用import语句引入包：
import java.util.Scanner;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
}
这样即可，如果需要使用包中许多的类可以直接使用import java.util.*；
import java.util.*;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
}
这样就可以使用所有这个包中的类了，但不会直接导入包中的所有的类，而是自己使用那个类时，系统自动加载那个类.
包中的类使用冲突：
import java.util.*;
import java.sql.*;
public static void main(String[] args) {
Date date = new Date();
System.out.println(date.getTime());
}
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
}
这种情况使用完整的类名.
2.3常用包介绍
三、static的使用
3.1static修饰变量
class Student {
private String name;
public static String classHome = "001";
}
public static void main(String[] args) {
System.out.println(Student.classHome);
Student student1 = new Student();
System.out.println(student1.classHome);
Student student2 = new Student();
System.out.println(student2.classHome);
}
我们可以通过以上对static变量的调用，可以发现以下几点：
3.2static修饰方法
一个类中的普通的成员属性使用private封装起来，实现public方法供外部调用。那private修饰的static的成员变量，外部如何访问呢？
class Student {
private String name;
private static String classHome = "001";
public static String getClassHome() {
return classHome;
}
}
public static void main(String[] args) {
System.out.println(Student.getClassHome());
}
静态方法的特性:
1.不属于具体的对象，是类的方法.
2.可以使用对象调用，但不推荐.
3.不能在静态方法中访问非静态成员变量.
4.不能在静态方法调用非静态方法.
四、代码块
4.1普通代码块
public static void main(String[] args) {
{
System.out.println("haha");
}
}
直接定义在方法中的代码块，即为普通代码块
4.2静态代码块
用于static修饰的代码块即为静态代码块，可初始化静态成员变量。
class Student {
public static String classHome;
static {
classHome = "001";
}
}
public static void main(String[] args) {
System.out.println(Student.classHome);
}
我们可以发现我们为new对象，直接打印static成员变量时，static成员变量已经经过static代码块赋值.
4.3实例代码块
实例代码块又称构造代码块，顾名思义是用来初始化普通成员变量的
class Student {
public String name;
public int age;
{
name = "张三";
age = 18;
}
}
public static void main(String[] args) {
Student student = new Student();
System.out.println("name: "+student.name+" age: "+student.age);
}
五、内部类
5.1什么是内部类
简单地说就是:定义在一个类内部的类
class OutClass{//外部类
class InnerClass{//内部类
}
}
注意: 虽然内部类外部类在一个java文件，但编译后会形成两个不同的字节码文件.
5.2静态内部类
class OutClass {
public int size;
static int age;
public void funcSize() {
System.out.println(size);
}
public static void funcAge() {
System.out.println(age);
}
static class InnerClass {
//静态内部类只能访问外部的静态成员和方法.
public void funInner() {
age = 18;
funcAge();
}
}
public static void main(String[] args) {
OutClass.InnerClass innerClass = new OutClass.InnerClass();
innerClass.funInner();
}
}
在内部类如何访问外部类的成员和方法？
static class InnerClass {
public void funInner() {
OutClass outClass = new OutClass();
outClass.size = 20;
outClass.funcSize();
age = 18;
funcAge();
}
}
我们可以通过外部类对象在内部类访问外部类成员变量和方法.
5.3实例内部类
class OutClass {
public int size;
static int age;
public void funcSize() {
System.out.println("size: "+size);
}
public static void funcAge() {
System.out.println("age: "+age);
}
class InnerClass {
String name;
public void funcInnerClass() {
size = 20;
age = 18;
name = "张三";
funcSize();
funcSize();
System.out.println("name: "+name);
}
}
当内部类中的成员变量和外部类重名了，怎么访问？
class InnerClass {
int size;
public void funcInnerClass() {
OutClass.this.size = 20;
age = 18;
funcSize();
funcAge();
}
}
可以通过外部类名.this.成员变量名访问.
5.4局部内部类
class OutClass {
int size = 20;
public void funcSize() {
int age = 18;
class InnerClass{
public void funcInnerClass() {
System.out.println(size);
System.out.println(age);
}
}
InnerClass innerClass = new InnerClass();
innerClass.funcInnerClass();
}
}
局部内部类是定义在外部类方法体或者普通代码块中的内部类.
