java 继承

理解封装的作用

为什么要使用封装

Penguin p=new Penguin();
p.health = -1000; //错的   健康值不可能为负
1
2
属性随意访问，不合理的赋值。
所以才要使用封装

什么是封装
面向对象的三特性：封装、继承、多态
面向对象特征：封装

封装的概念
将类的某些信息隐藏在类内部，不允许外部程序直接访问，
而是通过该类提供的方法来实现对隐藏信息的操作和访问
把尽可能多的东西藏起来，对外提供便捷的接口

封装目的是为了保护属性不被随意修改

如何实现封装:

私有化属性
（设为private关键字，防止错误的修改）
创建公共的getter/setter方法作为出口和入口
（用于属性的读写 ）
在getter/setter方法中加入属性控制语句
（对属性值的合法性进行判断 ）
赋值的时候调用setter方法，获取值的时候用getter方法
举例：

private String name;
public void setName(String name) {
    this.name = name;
}
public String getName() {
    return name;
}

p.setName("小猪");
String a = p.getName();
System.out.println(a);

如果有有参构造，则赋值时建议调用setter方法，保障逻辑完整性
有参构造是相当于另一个接口，那就是新的，此时属性都已经私有化，
之前的getter和setter方法是针对无参构造方法的，对有参构造不管用。

举例：

public Penguin(String name, int health) {
        this.name = name;
        setHealth(health);
    }

快捷键：
alt + shift + s
Source - Generate Getters and Setters

封装的好处:
便于使用者正确使用系统，防止错误修改属性
有助于系统之间的松耦合，提高系统独立性
提高软件的可重用性
降低了构建大型系统的风险

Java中的包组织类
为什么需要包
比如Windows树形文件系统

文档分门别类，易于查找和管理
使用目录解决文件同名冲突问题
包对应Java源文件的目录结构

包的作用 :（package）

允许类组成较小的单元（类似文件夹），
易于找到和使用相应的文件
防止命名冲突，区分名字相同的类
有助于实施访问权限控制
如何创建包
作为Java源代码第一条语句
用package声明包，以分号结尾
package xx.xxx;//声明包

包命名规范

包名由小写字母组成，不能以圆点开头或结尾
举例：package mypackage;
包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
举例：package net.javagroup.mypackage;
包名后续部分依不同机构内部的规范不同而不同
举例：package net.javagroup.research.powerproject;
JDK提供基本包
java.lang：虚拟机自动引入
java.util：提供一些实用类
java.io:输入、输出

java.lang等基本包下的所有类不需要import导入

使用MyEclipse创建包的两种方法
分别创建包和类
创建类的过程中创建类所在的包（如下）

如何导入包：
为了使用不在同一包中的类，
需要在Java程序中使用import关键字导入这个类。

import 包名. 类名；
举例：
import java.util.*; //导入java.util包中所有类
import cn.test.class.School; //导入指定包中指定类

系统包：java.util
自定义包：cn.test.class
*： 指包中的所有类，表示通配符
School ：指包中的School类
使用包的注意点：

一个类同时引用了两个来自不同包的同名类
必须通过完整类名来区分
每个包都是独立的，顶层包不会包含子包的类
package和import的顺序是固定的
==>package必须位于第一行（忽略注释行）
只允许有一个package语句
其次是import
接着是类的声明
不能删除包，不然会报错的(package) 。
默认包不要创建，不要放东西。
因为其他类想调用默认包里的，不能调用，比较麻烦，会找不到默认包下的对象。

导包快捷键：
ctrl + shift + o

掌握访问修饰符，理解访问权限
访问修饰符：

权限修饰（访问修饰符）：
public:公共的，工程内所有的类都能访问（绝大部分的方法）
protected:包级私有 + 子类，在默认修饰符的基础上加子类可访问
默认：包级私有，本包内所有类可以访问（临时变量）
private：私有的，只有本类可以访问(基本是所有的属性）

static关键字（修饰符）
static可以用来修饰

成员变量（属性）
静态变量，可以直接通过类名访问
成员方法
静态方法，可以直接通过类名访问
代码块
静态代码块，当Java虚拟机加载类时，就会执行该代码块
1、static在修饰属性时:

共用一个存储空间，不同对象调用时可以保存修改
（会有公用的空间，保障该类所有实例访问的是同一个位置）
可以不用对象调用（不用创建对象），而用类调用
静态属性可以在普通方法中调用，也可以在静态方法中调用
普通属性不能在静态方法中直接调用，需要用对象.属性的方式调用
类的成员变量包括
类变量（静态变量）

public class Stu {
static int a =1; //类属性
}

==>类的不同对象共用一个存储空间
（就是在main方法中使用时，不管创建了多少的对象，
里面只要有关a你都能使用）

概念：

类变量就是被static修饰的变量
在内存中只有一个拷贝
类内部，可在任何方法内直接访问静态变量
其他类中，可以直接通过类名访问
==>当你在外部去调用该类，可以直接用 类名.静态属性 来调用
好处是：不用建对象 Stu.a ++;
实例变量

int b =1;//对象属性   每创建一个对象就是一个新的b
1
==>每创建一个对象，那么b就只对该对象有作用

概念：

没有被static修饰的变量
每创建一个实例，就会为实例变量分配一次内存，
实例变量可以在内存中有多个拷贝，互不影响
static变量的作用：

public class StaticTest {
         static int num;
         public static void main(String[] args) {
                 num++;
                 StaticTest st1=new StaticTest();
                 st1.num++;
                 StaticTest st2=new StaticTest();
                 st2.num++;
                 StaticTest.num++;
                 System.out.println(num); 
        }
}

结果为：4
（1）能被类的所有实例共享，可作为实例之间进行交流的共享数据
（2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间

2、static修饰方法时（静态方法）:

public class Stu {
public static void aaa() {//类方法
    }
}

静态方法可以直接用类名.静态方法()调用
（在Stu中直接调用静态方法aaa();，同时在外部main调用可以通过
类来调用Stu.aaa();原因都是静态方法）
静态方法通常用于做工具方法()，不需要创建对象即可使用
（Array.toString(）Math.random() 等等都是属于静态方法）
静态方法可以调用静态方法，不能直接调用普通方法，需要用对象调用（创建对象）
普通方法可以直接调用静态方法和普通方法
注意点：

静态方法中不能使用this和super（它们是针对对象）
不能直接访问所属类的实例变量和实例方法
可直接访问类的静态变量和静态方法
main()就是最常用的静态方法

注意点：
在实例方法里不可以定义和使用static变量

实例（对象）方法：通过实例访问

可直接访问所属类的静态变量、静态方法、实例变量和实例方法
3、static代码块:

//静态代码块
public class Test1 {
    static {
        System.out.println("初始化之前就会执行，且只有一次");
    }
    public TestBlock() {
        System.out.println("自定义无参构造");
    }//无参构造方法只要创建一个对象就会走一次
    public static void main(String[] args) {
        Test1 t = new Test1();
        Test1 t2 = new Test1k();
        Test1 t3 = new Test1();
    }
}

结果:
初始化之前就会执行，且只有一次
自定义无参构造
自定义无参构造
自定义无参构造

静态代码块会在第一次访问该类型时，执行并只执行一次.
会在对象创建前就执行静态代码块(JVM加载类时，加载静态代码块)
如果有多个静态块，按顺序加载
静态代码块往往用于配置文件的导入，单例模式的关键点
举例：

public class StaticTest {
         static int num=100;
         static{
                num+=100;
               System.out.println(num);
         }
         static{
                num+=100;
               System.out.println(num); 
        }
}
1

StaticTest st1=new StaticTest();
StaticTest st2=new StaticTest();
System.out.println(StaticTest.num);

结果:
200
300
300

假设上面即使不写创建两个对象
但只要看到这个类型 比如类. 变量名
那么在执行这句话之前 就会调用 static 代码块

题外话：

静态成员变量在类加载的时候就进行了创建，在整个程序时按序销毁
实例变量在类实例化对象时候创建，在对象销毁的时候销毁
局部变量在局部范围使用时创建，跳出局部范围销毁

问题解决：
当遇到以下问题：
The left-hand side of an assignment must be a variable
其中之一的问题：
Java可把一个对象赋值给一个引用（变量），但是不能把对象赋值给对象 。
比如：h.getHeal() = h.getHeal() - damage;
相当于 5=5-1， 你get，只是拿到个数字，而不是这个变量，
而set 方法是专门给这个变量赋值的。
正确写法：setHeal(getHeal() - damage);

方法的定义没有先后顺序，只有实际调用的时候才看顺序

main方法不同，就路径也不同，是独立的，互不相干。

没有造对象 那么无参构造也不会调用