举例：
学生：增加，删除，修改，查询
老师：增加，删除，修改，查询
…
方案1：按照功能分
com.heima.add
AddStudent
AddTeacher
com.heima.delete
DeleteStudent
DeleteTeacher
com.heima.update
UpdateStudent
UpdateTeacher
com.heima.find
FindStudent
FindTeacher
方案2：按照模块分
com.heima.teacher
AddTeacher
DeleteTeacher
UpdateTeacher
FindTeacher
com.heima.student
AddStudent
DeleteStudent
UpdateStudent
FindStudent
*封装：隐藏实现细节，对外提供公共的访问方式
本类 同一个包下(子类和无关类) 不同包下(子类) 不同包下(无关类)
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
案例：
package com.heima;
import com.baidu.Person;
import com.xxx.Student;
//import java.util.Scanner; //在开发中我们用的都是导入具体的类
import java.util.; //代表通配符,他会到该包下挨个匹配,匹配上就导入
class Demo1_Package {
public static void main(String[] args) {
Person p = new Person("张三",23);
System.out.println(p.getName() + "…" + p.getAge());
//p.print(); //在不同包下的无关类,不允许访问,因为是protected修饰的
/Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
System.out.println(x);/
Student s = new Student("李四",24);
System.out.println(s.getName() + "..." + s.getAge());
s.method();
}
}
package com.baidu;
public class Person {
private String name;
private int age;
public Person(){}
public Person(String name,int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
protected void print() {
System.out.println("print");
}
}
package com.xxx;
import com.baidu.Person;
public class Student extends Person {
public Student(){}
public Student(String name,int age) {
super(name,age);
}
public void method() {
print();
}
}
B:类：
抽象修饰符：abstract
用的最多的就是：public
C:成员变量：
状态修饰符：static，final
用的最多的就是：private
D:构造方法：
权限修饰符：private，默认的，protected，public
用的最多的就是：public
E:成员方法：
抽象修饰符：abstract
用的最多的就是：public
F:除此以外的组合规则：
要求：使用已知的变量，在控制台输出30，20，10。
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(?);//num
System.out.println(??);//this.num
System.out.println(???);//Outer.this.num,内部类之所以能够访问外部类成员，因为它能获取外部类的引用Outer.this,outer下面的this的num
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
A:案例演示
局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?
因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用
但是jdk1.8取消了这个事情,所以我认为这是个bug
案例:
class Demo1_InnerClass {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
//局部内部类
class Outer {
public void method() {
final int num = 10;
class Inner {//局部内部类和局部变量一样，只在方法中有效，出了方法就无效了
public void print() {
System.out.println(num);
}
}
Inner i = new Inner();
i.print();
}
/public void run() {
Inner i = new Inner(); //局部内部类,只能在其所在的方法中访问
i.print();
}/
}
new 类名或者接口名(){
重写抽象类或者接口的方法;
} //只能用一次
E:案例演示
按照要求来一个匿名内部类
案例：
class Demo1_NoNameInnerClass {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
interface Inter {
public void print();
}
class Outer {
class Inner implements Inter {
public void print() {
System.out.println("print");
}
}
public void method(){
//Inner i = new Inner();
//i.print();
//new Inner().print();
//Inter i = new Inner(); //父类引用指向子类对象
new Inter() { //实现Inter接口
public void print() { //重写抽象方法
System.out.println("print");
}
}.print();
}
}
//这里写抽象类，接口都行
abstract class Person {
public abstract void show();
}
class PersonDemo {
public void method(Person p) {
p.show();
}
}
class PersonTest {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
PersonDemo pd = new PersonDemo ();
//请在此处补充代码
}
}
答案：
class Test1_NoNameInnerClass {
public static void main(String[] args) {
//如何调用PersonDemo中的method方法呢?
PersonDemo pd = new PersonDemo ();
//pd.method(new Student());
pd.method(new Person() {
public void show() {
System.out.println("show");//匿名对象类作为参数传递
}
});
}
}
//这里写抽象类，接口都行
abstract class Person {
public abstract void show();
}
class PersonDemo {
//public void method(Person p) { //Person p = new Student(); //父类引用指向子类对象
/*
Person p = new Person(){
public void show() {
System.out.println("show");
}
};
*/
public void method(Person p) {
p.show();
}
}
class Student extends Person {
public void show() {
System.out.println("show");
}
}
按照要求，补齐代码
interface Inter { void show(); }
class Outer { //补齐代码
}
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
/*分析:outer中必须有method方法,并且这个方法返回值一定是Iter的实现类对象
*/
}
}
}
要求在控制台输出”HelloWorld”
答案：
class Test2_NoNameInnerClass {
public static void main(String[] args) {
//Outer.method().show(); //链式编程,每次调用方法后还能继续调用方法,证明调用方法返回的是对象,.show说明调用了这份方法,那么这份方法必须被重写
// Inter i = Outer.method();
// i.show();
}
}
interface Inter {
void show(); //这是接口,要调用这个方法必须进行重写
}
class Outer {
//补齐代码
public static Inter method() {//返回值必须是Inter对象,要调用show,必须对show重写
return new Inter() {//匿名类对象格式:
public void show() {
System.out.println("HelloWorld");
}
};
}
}
//要求在控制台输出”HelloWorld”//按照要求，补齐代码
原文：http://www.cnblogs.com/itlyh/p/6024679.html