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

  • A:为什么要有包
    *开发时有很多类,如果放在一个文件夹中不方便管理,而且容易重复

    • 将字节码(.class)进行分类存放
    • 包其实就是文件夹
  • B:包的概述
  • 举例:
    学生:增加,删除,修改,查询
    老师:增加,删除,修改,查询

    方案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

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

  • A:定义包的格式

    • package 包名;
    • 多级包用.分开即可
  • B:定义包的注意事项
    • A:package语句必须是程序的第一条可执行的代码
    • B:package语句在一个java文件中只能有一个
    • C:如果没有package,默认表示无包名
  • C:案例演示
    • 包的定义及注意事项
      案例:
      package com.heima;
      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.heima;
      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 ctl,shif+o也可以导包

      • 其实就是让有包的类对调用者可见,不用写全类名了
        *导包后Person类对于Demo1_Package就可见了
  • B:导包格式
    • import 包名;
    • 注意:
    • 这种方式导入是到类的名称。
    • 虽然可以最后写*,但是不建议。
  • C:package,import,class有没有顺序关系(面试题)package必须第一句,只有一个,然后是import,可以有多句,然后是class
    案例:
    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);
    /
    }
    }
    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
    默认 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();
    }
    }

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 {//这个时候不可以在其他类里面使用Inner类,私有的
    public void method() {
    System.out.println(num);
    }
    }
    public void print() {
    Inner i = new Inner();
    i.method();
    }
    }

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

  • static
  • B:成员内部类被静态修饰后的访问方式是:
    • 外部类名.内部类名 对象名 = 外部类名.内部类对象;
      Outer.Inner oi = new Outer().new Inner();这是在普通成员类中,用来两个new实际创建了两个对象,一个内部类对象,一个外部类对象,注意其中有两个()分别调用了两个类的构造函数,
      Outer.Inner oi1 = new Outer.Inner(); 这是在静态成员类中只能用类名.内部类名的方式来,并且这种情况下只创建了一个内部类对象,没有创建外部类对象,因为只用了一个new
      案例:
      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,outer下面的this的num
}
}
}
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();
/*分析: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”//按照要求,补齐代码

10 面向对象(package关键字的概述及作用)的更多相关文章

  1. 面向对象this关键字和概述和应用

    面向对象this关键字和概述和应用 package thisdemo; /** * 面向对象this关键字和概述和应用 * */ //定义老师类 class Teacher { private Str ...

  2. 面向对象-this关键字的概述和应用

    /* 我们曾经说过:定义名字要做到见名知意. this:是当前类的对象引用.简单的记,它就代表当前类的一个对象. 注意:谁调用这个方法,在该方法内部的this就代表谁. this的场景: 解决局部变量 ...

  3. Java面向对象-package import关键字

    Java面向对象-package import关键字 package包关键字,在java中,有包的概念,主要是用来归类 分类作用: 便于项目的开发和维护: 这里截取随便截取一个我最近在开发的一个开源工 ...

  4. Java面向对象-static关键字、静态方法与普通方法、静态成员变量

    Java面向对象-static关键字.静态方法与普通方法 static关键字的基本作用:方便在没有创建对象的情况下来进行调用(方法/变量). 很显然,被static关键字修饰的方法或者变量不需要依赖于 ...

  5. Java基础语法(11)-面向对象之关键字

    title: Java基础语法(11)-面向对象之关键字 blog: CSDN data: Java学习路线及视频 1.this this是什么 它在方法内部使用,即这个方法所属对象的引用: clas ...

  6. 15-static和extern关键字1-对函数的作用

    一.extern与函数 如果一个程序中有多个源文件(.c),编译成功会生成对应的多个目标文件(.obj),这些目标文件还不能单独运行,因为这些目标文件之间可能会有关联,比如a.obj可能会调用c.ob ...

  7. C#面向对象特征的具体实现及作用详解

    转自:http://www.jb51.net/article/42390.htm 众所周知,面向对象编程的特点为:封装.继承.多态.C#是一门完全面向对象的语言,由于比Java推出的时间还要晚,所以对 ...

  8. JAVA面向对象-----final关键字

    JAVA面向对象-–final关键字 1:定义静态方法求圆的面积 2:定义静态方法求圆的周长 3:发现方法中有重复的代码,就是PI,圆周率. 1:如果需要提高计算精度,就需要修改每个方法中圆周率. 4 ...

  9. JAVA面向对象-----super关键字

    JAVA面向对象-–super关键字 1:定义Father(父类)类 1:成员变量int x=1; 2:构造方法无参的和有参的,有输出语句 2:定义Son类extends Father类 1:成员变量 ...

随机推荐

  1. 109、TensorFlow计算张量的值

    # 当计算图创建成功时 # 你就可以运行这个计算图,然后生成一个新的张量 # 并且得到这个张量指向的计算图中具体的数值 #这个功能在debug的时候非常有必要 #最简单获得张量具体值的方法是使用Ten ...

  2. mvc 当中 [ValidateAntiForgeryToken] 的作用 转载https://www.cnblogs.com/hechunming/p/4647646.html

    一.CSRF是什么? CSRF(Cross-site request forgery),中文名称:跨站请求伪造,也被称为:one click attack/session riding,缩写为:CSR ...

  3. chromedriver安装报错

     解决方法:   可以使用 npm init -f命令生成package.json,package.json中缺少的字段可以参照模板 package.json进行填充,package.json中的字段 ...

  4. 26. 60s快速定位服务器性能问题

    60s迅速发现性能问题 uptime dmesg | tail vmstat 1 mpstat -P ALL 1 pidstat 1 iostat -xz 1 free -m sar -n DEV 1 ...

  5. 用vim写go代码——vim-go插件

    GoImport:导入包 GoImport!:导入远程包 GoImportAs: 导入包并且重命名

  6. div中的div上下居中

    方法1: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 .parent {           width:800px;           height:500px;       ...

  7. intellij中maven不能导入pom文件中指定的jar包

    pom文件配置依赖的jar包版本,可以有默认的版本,如下 <profiles> <profile> <id>default_version</id> & ...

  8. BZOJ 4524(贪心+二叉堆)

    题面 若一个大于 11 的整数 M的质因数分解有 k 项,其最大的质因子为 \(a_k\),并且满足 \({a_k}^k \leq N,k<128\),我们就称整数 M 为 N-伪光滑数. 现在 ...

  9. python打包生成exe文件

    今天任务让做一个可以在Win上直接执行的脚本,百度了下原来可以生产.exe文件.神奇了 安装 pyInstaller pip install pyInstaller  进入要打包文件的目录 执行 py ...

  10. 开源图标字体 uiw-iconfont v1.2.6 发布,新增图标

    uiw-iconfont v1.2.6 已发布,uiw-iconfont 是从 uiw 组件库抽离出来的图标字体,基于 svg 图片生成的图标字体. 更新内容 新增 map android-o das ...