1：访问修饰符
private 同类中
默认 同类 同包
protect 同类 同包 子类
public 同类 同包 子类 其它任何地方
2：导包
当两个类同名时 需要进行导包以区分，
3：继承
1）继承成员变量，但与访问修饰符有关系。
4：继承中的构造方法
1）子类中的构造方法默认调用父类的无参构造，如果用super在子类构造中调用父类的有参构造就会将父类的无参构造覆盖，如果在子类构造方法中用this调用
子类其它构造方法也会将父类默认无参构造进行覆盖；
2）子类的同一个构造方法中不可以同时存在super和this因为他们都需要放在方法里面的第一行。
5：子类调用父类的无参构造方法 super（），子类调用父类的有参构造方法super(参数);
6：静态方法，静态代码块，构造方法
1）执行顺序：
静态方法1 静态方法 2 静态方法3
静态代码块4 静态代码块6 静态代码块8
构造方法 5 构造方法7 构造方法9
2）如果创建两个对象对子类进行调用 静态代码块只执行一次，代码块和构造方法执行两次，静态方法的执行取决于是否被调用
public class A {
static {
System.out.println("static A");
}
{
System.out.println("cdoe A ....");
}
public A() {
System.out.println("con A");
}
}
public class B extends A{
static {
System.out.println("staticB");
}
{
System.out.println("cdoeB ....");
}
public B() {
super();
System.out.println("con B");
}
}
public class C extends B{
static {
System.out.println("static C");
}
{
System.out.println("cdoe C ....");
}
public C() {
super();
System.out.println("con C");
}
}
public class Test {
public static void main(String[] args) {
C c = new C();
//
C c2 = new C();
}
}
7：同类中成员方法和静态方法 访问成员变量，静态变量和静态方法 成员方法
public class B {
private int age;
private static int love;
public void show() {
// 成员方法可以访问成员变量吗？ 1 访问静态变量吗？ 1
age = 13;
love = 14;
noShow();
}
// 在静态方法当中不能访问实例变量（成员变量）， 必须确保当前已经产生了实例，再使用实例访问。
public static void noShow() {
// love = 55;
//age=34; 报错
}
}
8：静态实例2
public class StaticA {
// static修饰 成员变量--》 变为类变量，静态变量
public static int year = 2000;
private static int love = -100;
private int age;
// 代码块，随着每个实例的创建都会执行一次
static {
System.out.println("静静地 睡觉！");
}
public StaticA() {
System.out.println("我的构造器");
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static void myLife() {
System.out.println("流浪。。。。");
}
}
public static void main(String[] args) {
StaticA s = new StaticA();
s.setAge(18);
StaticA s2 = new StaticA();
s2.setAge(19);
System.out.println(s.getAge());
System.out.println(s2.getAge());
// 类变量的值（访问，类名.变量名访问），所有的对象也可以访问
System.out.println(StaticA.year);
System.out.println(s.year);
System.out.println(s2.year);
s.year = 2001;
System.out.println(StaticA.year);
System.out.println(s.year);
System.out.println(s2.year);
// 使用静态方法 类名.方法名， 也可以使用对象.方法名
// 提供是共性的功能。 编写工具类，工具方法
StaticA.myLife();
s.myLife();
}
}
9：关于继承中静态代码块 代码块 无参构造 有参构造的执行情况
public class C {
private int age;
static {
System.out.println("C静态代码块");
}
{
System.out.println("C代码块");
}
public C() {
super();
System.out.println("C无参构造");
}
public C(int age) {
super();
this.age = age;
System.out.println("C有参构造");
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class B extends C{
private int name;
static {
System.out.println("B静态代码块");
}
{
System.out.println("B代码块");
}
public B() {
super();
System.out.println("B无参构造");
}
public B(int name) {
super();
this.name = name;
System.out.println("B有参构造");
}
}
public class A extends B{
private int tall;
static {
System.out.println("A静态代码块");
}
{
System.out.println("A代码块");
}
public A() {
super();
System.out.println("A无参构造");
}
public A(int tall) {
super();
this.tall = tall;
System.out.println("A有参构造");
}
public int getTall() {
return tall;
}
public void setTall(int tall) {
this.tall = tall;
}
}
public class TextABC {
public static void main(String[] args) {
A a = new A();
A b = new A(6);
}
}
/*c静态代码块
b静态代码块
a静态代码块
c代码块
c无参
b代码块
b无参
a代码块
a无参
c代码块
c无参
b代码块
b无参
a代码块
ay有参
*/