13_java Object _ 13th day (static, final, anonymous object, inner class, package, modifier, code block) _ Handout

Introduction of today's content
1. Final keyword
2. Static keyword
3. Anonymous objects
4. Inner class
5. Claims and access to packages
6. Access modifiers
7. Code block

01final keyword Concepts

• A: Overview

•   继承的出现提高了代码的复用性，并方便开发。但随之也有问题，有些类在描述完之后，不想被继承，  或者有些类中的部分方法功能是固定的，不想让子类重写。可是当子类继承了这些特殊类之后，  就可以对其中的方法进行重写，那怎么解决呢？  要解决上述的这些问题，需要使用到一个关键字final，final的意思为最终，不可变。  final是个修饰符，它可以用来修饰类，类的成员，以及局部变量。

02final Modified class semantics

• A:final Modified Class

•   final修饰类不可以被继承，但是可以继承其他类。

• B: Case

•   class Yy {}  final class Fu extends Yy{} //可以继承Yy类  class Zi extends Fu{} //不能继承Fu类

03final Modification Method

• A:final Modification Method

•       final修饰的方法不可以被覆盖,但父类中没有被final修饰方法，子类覆盖后可以加final。

• B: Case

•   class Fu {      // final修饰的方法，不可以被覆盖，但可以继承使用      public final void method1(){}      public void method2(){}  }  class Zi extends Fu {      //重写method2方法      public final void method2(){}  }

04final modifying local variables

• A: Modifying basic data type variables

    final修饰的变量称为常量，这些变量只能赋值一次

• B: Case 1

•   final int i = 20;  i = 30; //赋值报错，final修饰的变量只能赋值一次

• C: Modify Reference data type

•   引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改

• D: Modifying reference data types

•   final Person p = new Person();  Person p2 = new Person();  p = p2; //final修饰的变量p，所记录的地址值不能改变  p.name = "小明";//可以更改p对象中name属性值  p不能为别的对象，而p对象中的name或age属性值可更改。

05final Decorated member variables

• A: Modifying member variables

•   修饰成员变量，需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)

• B: Case

•   class Demo {      //直接赋值      final int m = 100;      //final修饰的成员变量，需要在创建对象前赋值，否则报错。      final int n;       public Demo(){          //可以在创建对象时所调用的构造方法中，为变量n赋值          n = 2016;      }  }

Concept of 06static

• A: Concept

    当在定义类的时候，类中都会有相应的属性和方法。而属性和方法都是通过创建本类对象调用的。  当在调用对象的某个方法时，这个方法没有访问到对象的特有数据时，方法创建这个对象有些多余。  可是不创建对象，方法又调用不了，这时就会想，那么我们能不能不创建对象，就可以调用方法呢？  可以的，我们可以通过static关键字来实现。static它是静态修饰符，一般用来修饰类中的成员。

07static decorated object-specific data

• A: Feature 1:

•   被static修饰的成员变量属于类，不属于这个类的某个对象。  （也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，  其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）

• B: Code Demo

•   class Demo {      public static int num = 100;  }  class Test {      public static void main(String[] args) {          Demo d1 = new Demo();          Demo d2 = new Demo();          d1.num = 200;          System.out.println(d1.num); //结果为200          System.out.println(d2.num); //结果为200      }  }

08static of Memory diagram

09static precautions _ static cannot directly invoke non-static

• A: Precautions?
  

•   被static修饰的成员可以并且建议通过类名直接访问。

• B: Access to static member formats:

•   类名.静态成员变量名  类名.静态成员方法名(参数)  对象名.静态成员变量名             ------不建议使用该方式，会出现警告  对象名.静态成员方法名(参数)     ------不建议使用该方式，会出现警告

• C: Code Demo

•   class Demo {      //静态成员变量      public static int num = 100;      //静态方法      public static void method(){          System.out.println("静态方法");      }  }  class Test {      public static void main(String[] args) {          System.out.println(Demo.num);          Demo.method();      }  }

10static Static usage Scenarios

• A: Usage Scenarios

    static可以修饰成员变量和成员方法。      什么时候使用static修饰成员变量？      加static修饰成员的时候，这个成员会被类的所有对象所共享。一般我们把共性数据定义为静态的变量  什么时候使用static修饰成员方法？      静态的方法只能访问静态的成员，如果静态方法中引用到了静态的其他成员，那么这个方法需要声明为静态的方法。

11 static calls in an object

• A: Static invocation of an object

•     在多态中，非静态编译看父类，运行看子类，父类没有编译失败。    但多态中的静态方法,编译看父类,运行仍然看父类。因为静态和对象没有关系，属于静态绑定。

• B: Example

•   public class Test{      public static void main(String[] args){          Fu f = new Zi();          f.show();   //父类的引用和父类的方法绑定,和对象无关,不会在运行时动态的执行子类特有的方法。      }      }

12 Defining static constants

• A: Static Constants
  • In development, we want to define a static constant in the class, usually using the public static final modified variable to complete the definition.
    At this point the variable name is in all uppercase, and multiple words are concatenated with underscores.
• B: Define the format:

•   public static final 数据类型 变量名 = 值;

• C: The following demo:

•   class Company {      public static final String COMPANY_NAME = "传智播客";      public static void method(){          System.out.println("一个静态方法");      }  }  当我们想使用类的静态成员时，不需要创建对象，直接使用类名来访问即可。  System.out.println(Company.COMPANY_NAME); //打印传智播客  Company.method(); // 调用一个静态方法

• D: Note:

•   接口中的每个成员变量都默认使用public static final修饰。  所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值。可以直接用接口名访问。  interface Inter {      public static final int COUNT = 100;  }      访问接口中的静态变量  Inter.COUNT

13 Anonymous Objects

* A: An overview of Anonymous objects * An anonymous object is a statement that creates an object, but does not assign an object address value to a variable.    * B: Case public class person{public void Eat () {System.out.println ();    }} Create a normal object person P = new person ();        Create an anonymous object new person (); * C: Characteristics of Anonymous Objects A: Create anonymous objects directly using, without variable names.    The new person (). Eat ()//eat method is called by a person object that has no name.        B: An anonymous object can only be used once if its reference variable is not specified. New person (). Eat (); Creates an anonymous object that calls the Eat method new person (). Eat (); To call the Eat method again, recreate an anonymous object C: An anonymous object can be used as a method to receive parameters, method return values using class Demo {public static person Getperson (                  ) {//Normal mode//person p = new person ();                                return p;             The anonymous object is returned as a method return value return new person (); public static void method (person p) {}} class Test {public static void                                Main (string[] args) {//Call Getperson method, get a person object person person = Demo.getperson (); Call meThod method Demo.method (person);            The anonymous object is the parameter Demo.method received as a method (new person ()); }        }

14 Internal classes

• A: An overview of the inner classes

•   将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。  其他类也称为外部类。

• B: When to use internal classes

•   在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，  这时发动机就可以使用内部类来描述。  class 汽车 { //外部类      class 发动机 { //内部类      }  }

• C: Classification of inner classes

•   内部类分为成员内部类与局部内部类。  我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。  在内部类中可以直接访问外部类的所有成员。

15 invocation format for members inner classes

* A: 格式    成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问* B: 定义格式    class 外部类 {         修饰符 class 内部类 {            //其他代码        }    }* C: 访问方式    外部类名.内部类名 变量名 = new 外部类名().new 内部类名();* D: 成员内部类代码演示    class Body {//外部类，身体         private boolean life= true; //生命状态         public class Heart { //内部类，心脏             public void jump() {                 System.out.println("心脏噗通噗通的跳")                    System.out.println("生命状态" + life); //访问外部类成员变量            }        }    }    访问内部类    public static void main(String[] args) {        //创建内部类对象        Body.Heart bh = new Body().new Heart();        //调用内部类中的方法        bh.jump();    }

16 member inner class with the same name variable call

• A: Code Implementation

•   public class Outer {      int i  = 1;      class Inner {          int i  = 2;          public void inner(){              int i = 3;              System.out.println(Outer.this.i);          }      }  }

17 Local Inner class

• A local inner class that defines the local location in the outer class method. Similar to a local variable in an access method, it can be accessed by invoking a method.

• B Defining the Format

•   class 外部类 {       修饰符 返回值类型 方法名(参数) {          class 内部类 {              //其他代码          }      }  }

• C access Mode

•       在外部类方法中，创建内部类对象，进行访问

• D local inner Class code demo

    定义类  class Party {//外部类，聚会      public void puffBall(){// 吹气球方法          class Ball {// 内部类，气球                public void puff(){                  System.out.println("气球膨胀了");                }          }          //创建内部类对象，调用puff方法          new Ball().puff();      }  }  访问内部类  public static void main(String[] args) {          //创建外部类对象      Party p = new Party();      //调用外部类中的puffBall方法      p.puffBall();  }

18 Anonymous Inner class

• A: Overview

     内部类是为了应对更为复杂的类间关系。查看源代码中会涉及到，而在日常业务中很难遇到，这里不做赘述。   最常用到的内部类就是匿名内部类，它是局部内部类的一种。   定义的匿名内部类有两个含义：   临时定义某一指定类型的子类   定义后即刻创建刚刚定义的这个子类的对象

• B: Nature

     匿名内部类的本质是一个实现了接口或继承了某个类的子类匿名对象.

• C: Case

    public interface Smoking {      public abstract void smoking();      }      /*       *  实现类,实现接口 重写接口抽象方法,创建实现类对象       *  class XXX implements Smoking{       *      public void smoking(){       *             *      }       *  }       *  XXX x = new XXX();       *  x.smoking();        *  Smoking s = new XXX();       *  s.smoking();       *         *  匿名内部类,简化问题:  定义实现类,重写方法,建立实现类对象,合为一步完成       */

Test class:

    public class Test {        public static void main(String[] args) {            //使用匿名内部类            /*             *  定义实现类,重写方法,创建实现类对象,一步搞定             *  格式:             *    new 接口或者父类(){             *       重写抽象方法             *    };             *    从 new开始,到分号结束             *    创建了接口的实现类的对象             */            new Smoking(){                public void smoking(){                    System.out.println("人在吸烟");                }            }.smoking();        }    }

19 Anonymous Inner class _2

• A: Anonymous internal class case demo

        public abstract class Animal {          public abstract void eat();          public abstract void sleep();      }

Test code

/* *    new Animal(){            public void eat(){                System.out.println("在吃饭");            }             public void sleep(){                System.out.println("在睡觉");            }         };    以上代码,就是Animal的子类的对象    多态性, 父类引用 = 子类的对象 */public class Test2 {    public static void main(String[] args) {        Animal a= new Animal(){            public void eat(){                System.out.println("在吃饭");            }             public void sleep(){                System.out.println("在睡觉");            }         };         a.eat();         a.sleep();    }}

20 Concept of the package

• A: Concept

   java的包，其实就是我们电脑系统中的文件夹，包里存放的是类文件。 当类文件很多的时候，通常我们会采用多个包进行存放管理他们，这种方式称为分包管理。 在项目中，我们将相同功能的类放到一个包中，方便管理。并且日常项目的分工也是以包 作为边界。 类中声明的包必须与实际class文件所在的文件夹情况相一致，即类声明在a包下， 则生成的.class文件必须在a文件夹下，否则，程序运行时会找不到类。

• B Declaration Format

•   通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接      类中包的声明格式：   package 包名.包名.包名…;      如：黑马程序员网址itheima.com那么网址反写就为com.itheima          传智播客 itcast.cn  那么网址反写就为 cn.itcast      注意：声明包的语句，必须写在程序有效代码的第一行（注释不算）  代码演示：  package cn.itcast; //包的声明，必须在有效代码的第一行  import java.util.Scanner;  import java.util.Random;  public class Demo {}

• C: Access to the package

•   在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.类名）。  包名.包名….类名  如： java.util.Scanner       java.util.Random      cn.itcast.Demo  带有包的类，创建对象格式：包名.类名 变量名 = new包名.类名();       cn.itcast.Demo d = new cn.itcast.Demo();      前提：包的访问与访问权限密切相关，这里以一般情况来说，即类用public修饰的情况。      类的简化访问  当我们要使用一个类时，这个类与当前程序在同一个包中（即同一个文件夹中）  ，或者这个类是java.lang包中的类时通常可以省略掉包名，直接使用该类。  如：cn.itcast包中有两个类，PersonTest类，与Person类。我们在PersonTest类中，      访问Person类时，由于是同一个包下，访问时可以省略包名，即直接通过类名访问 Person。  类名 变量名 = new类名();  Person p = new Person();      当我们要使用的类，与当前程序不在同一个包中（即不同文件夹中），      要访问的类必须用public修饰才可访问。  package cn.itcst02;  public class Person {}

22 Importing Packages

• A: Importing Packages

•   我们每次使用类时，都需要写很长的包名。很麻烦，我们可以通过import导包的方式来简化。  可以通过导包的方式使用该类，可以避免使用全类名编写（即，包类.类名）。  导包的格式：  import 包名.类名;      当程序导入指定的包后，使用类时，就可以简化了。演示如下  //导入包前的方式  //创建对象  java.util.Random r1 = new java.util.Random();  java.util.Random r2 = new java.util.Random();  java.util.Scanner sc1 = new java.util.Scanner(System.in);  java.util.Scanner sc2 = new java.util.Scanner(System.in);  //导入包后的方式  import java.util.Random;  import java.util.Scanner;  //创建对象  Random r1 = new Random();  Random r2 = new Random();  Scanner sc1 = new Scanner(System.in);  Scanner sc2 = new Scanner(System.in);  import导包代码书写的位置：在声明包package后，定义所有类class前，使用导包import包名.包名.类名;

23 Permission Modifiers

• A what are the permission modifiers

•       在Java中提供了四种访问权限，使用不同的访问权限时，被修饰的内容会有不同的访问权限，      以下表来说明不同权限的访问能力：                             public          protected     default       private      同一类中                 √                √             √             √      同一包中(子类与无关类)     √                √              √       不同包的子类           √                √              不同包中的无关类         √         

• B: summary

•   归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问  要想仅能在本类中访问使用private修饰；  要想本包中的类都可以访问不加修饰符即可；  要想本包中的类与其他包中的子类可以访问使用protected修饰  要想所有包中的所有类都可以访问使用public修饰。  注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

24 Code blocks

• A: Overview:

    程序中用大括号括起来的代码叫代码块

• B: Classification

•   局部代码块  构造代码块  静态代码块  同步代码块

• C Local code block:

•   局部代码块是定义在方法或语句中  特点：      以”{}”划定的代码区域，此时只需要关注作用域的不同即可      方法和类都是以代码块的方式划定边界的    class Demo{          public static void main(String[] args)  {              {                       int x = 1;                       System.out.println("普通代码块" + x);              }              int x = 99;              System.out.println("代码块之外" + x);          }    }    结果：      普通代码块1      代码块之外99    局部代码块作用:可以限定变量的声明周期.

• D: Building Blocks of code

•   构造代码块是定义在类中成员位置的代码块  特点：      优先于构造方法执行，构造代码块用于执行所有对象均需要的初始化动作      每创建一个对象均会执行一次构造代码块。  public class Person {      private String name;      private int age;       //构造代码块      {          System.out.println("构造代码块执行了");      }      Person(){          System.out.println("Person无参数的构造函数执行");      }      Person(int age){          this.age = age;          System.out.println("Person（age）参数的构造函数执行");      }  }  class PersonDemo{      public static void main(String[] args)  {          Person p = new Person();          Person p1 = new Person(23);      }  }

• E: Static code block

•   静态代码块是定义在成员位置，使用static修饰的代码块。  特点：      它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。      该类不管创建多少对象，静态代码块只执行一次。      可用于给静态变量赋值，用来给类进行初始化。      public class Person {          private String name;          private int age;           //静态代码块          static{              System.out.println("静态代码块执行了");          }      }

• F: Synchronous code block (multithreaded learning)

Job Testing

What are the characteristics of 1.final modified, modified, and modified variables?

2. Is there a sequential relationship between Package,import,class?

3. What are the permissions modifiers in Java?

4. What are the characteristics of internal class access?

5. Local internal class accesses local variables, which keyword must be used to decorate the local variables, why?

6. The internal class format? What is the nature of it?

7. What are the prerequisites for the anonymous inner class, and what are the formats?

8. What are the categories of code blocks?

9. Do not run the following code: dictate print Results

class Student {                  static {               System.out.println("Student 静态代码块");        }            {                System.out.println("Student 构造代码块");        }            public Student() {                  System.out.println("Student 构造方法");        }}class Demo2_Student {        static {              System.out.println("Demo2_Student静态代码块");        }              public static void main(String[] args) {            System.out.println("我是main方法");                        Student s1 = new Student();                Student s2 = new Student();        }}

10. Please write an abstract class phone, two abstract methods, call () SendMessage ()
Two subcategories of Oldphone and Newphone, where Newphone wanted to add a game-playing feature.
Please follow the idea of the interface, and invoke the function of playing the game in the way of anonymous inner class.

13_java Object _ 13th day (static, final, anonymous object, inner class, package, modifier, code block) _ Handout