内部类可以使用任何访问控制符，内部类也可以直接访问外部类的任何成员不论是否私有，内部类对象需要通过外部类对象来创建，不可独自创建;

格式：内部类 对象名=外部类对象.new 内部类(); 

内部类成员的class文件名:  外部类名$内部类名.class

package com.hu;

public abstract class Person {
	public abstract void speak();
	}

public class Chinese extends Person {
	@Override	
	public void speak() {		
	// TODO Auto-generated method stub		
	System.out.println("中国人说中文");	
	}
    }
    
public class American extends Person {
	@Override	
	public void speak() {		
	// TODO Auto-generated method stub		
	System.out.println("美国人说英语");	
	}
    }
    
public class Initail {
	public static void main(String[] args) {		
	// TODO Auto-generated method stub
	Person ps1 = new Chinese();		
	ps1.speak();		
	Person ps2 = new American();		
	ps2.speak();	
	}
}

father.java
package com.demo10;
public class father {    
    //private int age;    
    public int age = 30;    
    public String name = "M";    
    public void talk(){        
    System.out.println("我是父类但是被子类继承调用了");
    }
}
son.java
package com.demo10;
public class son extends father{}
inheritTest.java
package com.demo10;
public class inheritTest {    
    public static void main(String[] args){        
        son s = new son();        
        s.talk();        
        System.out.println("name is "+s.name+"\n"+"age is "+s.age);    
    }
}

equals（）----返回值是布尔类型
比较的是对象的引用是否指向同一块内存地址-------对象实例化时，即给对象分配内存空间
使用方法如：dog.equals(dog2);
如果是两个对象，但想判断两个对象的属性是否相同，则重写equals（）方法
1.地址是否相同----if (this == obj)
2.对象是否为空----if (obj == null)
3.getClass（）可以得到类对象，判断类型是否一样-----if (getClass() != obj.getClass())
new出来的是类的对象，关注的是类的属性的具体的数据；
类对象是类的代码信息，关注的是类有什么属性和方法
4.属性值是否一样----if (age != other.age)

final关键字： 表示“最终的”，即不可修改。
final可以修饰类、方法、属性和变量
1、修饰类：不允许被继承
2、修饰方法：不允许被重写
3、修饰属性：则该属性不会进行隐式初始化（不会自动初始化），需要手动初始化或者在构造方法中初始化 （但二者只能选一，即只能初始化一次后便不能更改）
4、修饰变量，只能在声明的时候赋一次值，成为常量。 （static final 会使其成为全局常量）

重写方法的规则：

1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。

2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。如果在子类中写了一个只有返回类型不同的函数，将不是重写，且会报错

3、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）

4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：

父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

1、继承的概念：继承是类与类的一种关系；Java中的继承是单继承，只有一个父类。
2、继承的好处：子类直接拥有父亲的所有属性和方法。---private实现的无效！注意：private修饰的父类属性和方法不能被继承！            

   代码可复用。
class 子类 extends 父类{……}

内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

1. 若在Eclipse中，类里创建了private属性，这里可以利用Eclipse快捷键自动创建get set方法.
(点击Eclipse ， sources(源码) ,下面有一个setter...代表自动创建入口方法)
1.this关键字代表当前对象
this.属性 操作当前对象的属性
this.方法 调用当前对象的方法
2.封装对象的属性的时候，经常会使用this关键字
public void setJia(double jia){
this.jia=jia;//this.属性=参数；就是将参数的值付给当前对象的属性（为了区分属性和参数）
this.sendMessage();//this.方法；就是调用当前对象的sendMessage（）方法。
}

private 同类
默认 同类 同包
protecte 同类 同包 子类
public 同类 同包 子类 其他

类名相同的可以用包名来区分
java.lang.(类) 放置java语言基础类
java.util.(类)放置java语言工具类
java.io.(类)包含输入输出相关功能的类

用import来显示在某个文件中的其他文件中的类
在包中不能存放相同名字的类
默认情况下会把同一个包名导入进来
包 名全部是小写

面向对象的三大特性：封装、继承、多态
封装：
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
好处：只能通过规定的方法访问数据；隐藏类的实例细节，方便修改和实现。
封装实现方法：1）、修改属性可见性。2）、创建getter\setter方法。3）、在getter\setter中加入属性控制语句(对属性值的合法性进行判断)。
封装 ： 1.类变成private float screen;
2. 加get/set
public float getScreen(){
return screen;
}
public void setScreen(float newScreen){
screen=newScreen;
}
3. main调用： phone.setscreen(6.0f);
System.out.printly(phone.getScreen());
好处：只能通过规定的方法访问数据；隐藏类的实例细节，方便修改和实现。

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

1. 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员.如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量
2.在普通成员方法中，则可以直接访问同类的非静态变量和静态变量
3. 静态方法中可以直接调用静态方法，但不能直接调用非静态方法，需要通过对象来访问非静态方法
4.注意main函数是一个静态函数

2、 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：