挖穿Android第十天

10.01_面向对象(package关键字的概述及作用)

• A:为什么要有包

  开发时有很多类，如果放在一个文件夹中不方便管理，而且容易重复

• 将字节码(.class)进行分类存放

• 包其实就是文件夹

• B:包的概述

举例：

学生：增加，删除，修改，查询

老师：增加，删除，修改，查询

方案1：按照功能分

com.ziyang.add

AddStudent

AddTeacher

com.ziyang.delete

DeleteStudent

DeleteTeacher

com.ziyang.update

UpdateStudent

UpdateTeacher

com.ziyang.find

FindStudent

FindTeacher

方案2：按照模块分

com.ziyang.teacher

AddTeacher

DeleteTeacher

UpdateTeacher

FindTeacher

com.ziyang.student

AddStudent

DeleteStudent

UpdateStudent

FindStudent

10.02_面向对象(包的定义及注意事项)

• A:定义包的格式

• package 包名;

• 多级包用.分开即可

• B:定义包的注意事项

• A:package语句必须是程序的第一条可执行的代码

• B:package语句在一个java文件中只能有一个

• C:如果没有package，默认表示无包名

• C:案例演示

• 包的定义及注意事项

案例：

package com.ziyang;
class Demo1_Package {
 public static void main(String[] args) {
 System.out.println("Hello World!");
	 }
}

10.03_面向对象(带包的类编译和运行)

• A:如何编译运行带包的类

• a:javac编译的时候带上-d即可

• javac -d . HelloWorld.java

• b:通过java命令执行。

• java 包名.HellWord

10.04_面向对象(不同包下类之间的访问)(掌握)

• A:案例演示

• 不同包下类之间的访问

案例：

package com.ziyang;
class Demo1_Package {
 public static void main(String[] args) {
 com.baidu.Person p = new com.baidu.Person("张三",23);
 System.out.println(p.getName() + "..." + p.getAge())； 
 }
}
​
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;
 }
}

10.05_面向对象(import关键字的概述和使用)

• A:案例演示

• 为什么要有import

• 其实就是让有包的类对调用者可见,不用写全类名了

*导包后Person类对于Demo1_Package就可见了

• B:导包格式

• import 包名;

• 注意：

• 这种方式导入是到类的名称。

• 虽然可以最后写*，但是不建议。

• C:package,import,class有没有顺序关系(面试题)

案例：

package com.ziyang;
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);*/ 
 }
}
​
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;
 }
}

10.06_面向对象(四种权限修饰符的测试)

封装：隐藏实现细节，对外提供公共的访问方式

• A:案例演示

• 四种权限修饰符

• B:结论

本类 同一个包下(子类和无关类)不同包下(子类)不同包下(无关类)

private Y

默认YY

protectedYYY

publicYYYY

案例：

package com.ziyang;
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();
 }
}

10.07_面向对象(类及其组成所使用的常见修饰符)(掌握)

• A:修饰符：

• 权限修饰符：private，默认的，protected，public

• 状态修饰符：static，final

• 抽象修饰符：abstract

• B:类：

• 权限修饰符：默认修饰符，public，外部类不能用私有的

• 状态修饰符：final

• 抽象修饰符：abstract

• 用的最多的就是：public

• C:成员变量：

• 权限修饰符：private，默认的，protected，public

• 状态修饰符：static，final

• 用的最多的就是：private

• D:构造方法：

• 权限修饰符：private，默认的，protected，public

• 用的最多的就是：public

• E:成员方法：

• 权限修饰符：private，默认的，protected，public

• 状态修饰符：static，final

• 抽象修饰符：abstract

• 用的最多的就是：public

• F:除此以外的组合规则：

• 成员变量：public static final

• 成员方法：

• public static

• public abstract

• public final

10.08_面向对象(内部类概述和访问特点)

• A:内部类概述

• B:内部类访问特点

• a:内部类可以直接访问外部类的成员，包括私有。

• b:外部类要访问内部类的成员，必须创建对象。

• 外部类名.内部类名 对象名 = 外部类对象.内部类对象;

• C:案例演示

• 内部类极其访问特点

案例：

class Demo1_InnerClass {
 public static void main(String[] args) {
 //Inner i = new Inner();
 //i.method();
 //外部类名.内部类名 = 外部类对象.内部类对象
 Outer.Inner oi = new Outer().new Inner(); //创建内部类对象
 oi.method();
​
 }
}
class Outer {
 private int num = 10;
 class Inner {
 public void method() {
 System.out.println(num);
 }
 }
} 

10.09_面向对象(成员内部类私有使用)

private：在外部不能直接创建内部类对象了

案例:

class Demo2_InnerClass {
 public static void main(String[] args) {
 //Outer.Inner oi = new Outer().new Inner();
 //oi.method();
​
 Outer o = new Outer();
 o.print();
 }
}
​
class Outer {
 private int num = 10;
 private class Inner {
 public void method() {
 System.out.println(num);
 }
 }
​
 public void print() {
 Inner i = new Inner();
 i.method();
 }
}

10.10_面向对象(静态成员内部类)

• static

• B:成员内部类被静态修饰后的访问方式是:

• 外部类名.内部类名 对象名 = 外部类名.内部类对象;

案例：

class Demo1_InnerClass {
 public static void main(String[] args) {
 //外部类名.内部类名 对象名 = 外部类名.内部类对象;
 Outer.Inner oi = new Outer.Inner();
 oi.method();
​
 Outer.Inner2.print();
 }
}
​
class Outer {
 static class Inner {
 public void method() {
 System.out.println("method");
 }
 }
​
 static class Inner2 {
 public static void print() {
 System.out.println("print");
 }
 }
}

10.11_面向对象(成员内部类的案例)

• A:案例

要求：使用已知的变量，在控制台输出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
		 }
	 }
 }
 class InnerClassTest {
 public static void main(String[] args) {
 Outer.Inner oi = new Outer().new Inner();
 oi.show();
	 } 
 }

10.12_面向对象(局部内部类访问局部变量的问题)

• A:案例演示

• 局部内部类访问局部变量必须用final修饰

• 局部内部类在访问他所在方法中的局部变量必须用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();
 }*/
}

10.13_面向对象(匿名内部类的格式和理解)

• A:匿名内部类

• 就是内部类的简化写法。

• B:前提：存在一个类或者接口

• 这里的类可以是具体类也可以是抽象类。

• C:格式：

new 类名或者接口名(){

重写方法;

}

• D:本质是什么呢?

• 是一个继承了该类或者实现了该接口的子类匿名对象。

• 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();
 }
}

10.14_面向对象(匿名内部类重写多个方法调用)

• A:案例演示

• 匿名内部类的方法调用

案例:

class Demo2_NoNameInnerClass {
 public static void main(String[] args) {
 Outer o = new Outer();
 o.method();
 }
}
​
interface Inter {
 public void show1();
 public void show2();
}
//匿名内部类只针对重写一个方法时候使用
class Outer {
 public void method() {
 /*new Inter(){
 public void show1() {
 System.out.println("show1");
 }
​
 public void show2() {
 System.out.println("show2");
 }
 }.show1();
​
 new Inter(){
 public void show1() {
 System.out.println("show1");
 }
​
 public void show2() {
 System.out.println("show2");
 }
 }.show2();*/
​
 Inter i = new Inter(){
 public void show1() {
 System.out.println("show1");
 }
​
 public void show2() {
 System.out.println("show2");
 }
​
 /*public void show3() {
 System.out.println("show3");
 }*/
 };
​
 i.show1();
 i.show2();
 //i.show3(); //匿名内部类是不能向下转型的,因为没有子类类名
 }
}

10.15_面向对象(匿名内部类在开发中的应用)

• A:代码如下

//这里写抽象类，接口都行

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");
 }
}

10.16_面向对象(匿名内部类的案例)

• A:面试题

按照要求，补齐代码

interface Inter { void show(); }

class Outer { //补齐代码 }

class OuterDemo {

public static void main(String[] args) {

Outer.method().show();

}

}

要求在控制台输出”HelloWorld”

答案：

class Test2_NoNameInnerClass {

public static void main(String[] args) {

//Outer.method().show();//链式编程,每次调用方法后还能继续调用方法,证明调用方法返回的是对象

Inter i = Outer.method();

i.show();

}

}

//按照要求，补齐代码

interface Inter {

void show();

}

class Outer {

//补齐代码

public static Inter method() {

return new Inter() {

public void show() {

System.out.println("show");

}

};

}

}

//要求在控制台输出”HelloWorld”