Control properties for Android

Control properties:

Android Properties

Android is powerful, the interface is gorgeous, but many of the layout attributes of the pain of the developers, the following article combines a lot of information on the Internet,

First Class: Property value is True or false
android:layout_centerhrizontal   horizontally centered
android:layout_centervertical    Center vertically
android:layout_centerinparent    fully centered relative to parent element
Android:layout_alignparentbottom snaps to the bottom edge of the parent element
android:layout_alignparentleft    Snaps to the left edge of the parent element
android:layout_alignparentright   Snaps to the right edge of the parent element
android:layout_alignparenttop    snaps to the top edge of the parent element
Android:layout_alignwithparentifmissing    if the corresponding sibling element cannot be found, make a reference to the parent element.
Class II: The attribute value must be the referenced name of the id "@id/id-name"
android:layout_below       below an element
android:layout_above       at the top of an element
android:layout_toleftof    On the left side of an element
android:layout_torightof   to the right of an element
android:layout_aligntop    Aligns the top edge of this element with the top edge of an element
android:layout_alignleft   the left edge of this element and the left edge of an element
Android:layout_alignbottom Aligns the bottom edge of this element and the bottom edge of an element to
android:layout_alignright   the right edge of this element and the right edge of an element

Class III: Attribute values are specific pixel values, such as 30dip,40px
Android:layout_marginbottom distance from the bottom edge of an element
Android:layout_marginleft distance from the left edge of an element
Android:layout_marginright distance from the right edge of an element
Android:layout_margintop distance from the top edge of an element

EditText the Android:hint setting EditText is empty when the message is in the input box.
Android:gravity
The Android:gravity property is the qualification for the view content.  For example, a button above the text. You can set the text on the left side of the view, on the right, and so on. Take the button as an example, android:gravity= "right" then the text on the button
Android:layout_gravity
Android:layout_gravity is used to set the position of the view relative to the parent view. For example, a button in the LinearLayout, you want to put the button on the left, right and other positions can be set by this property. Take button For example, android:layout_gravity= "right" button on
Android:scaletype:
Android:scaletype is a size that controls how the picture resized/moved to the ImageView. The meaning difference of Imageview.scaletype/android:scaletype value:
Center/center is centered on the original size of the image, and when the picture is longer/wider than the length/width of the view, the center portion of the image is displayed
Center_crop/centercrop proportionally enlarges the size of the image so that the image is long (wide) equal to or greater than the length (width) of the view
Center_inside/centerinside Displays the contents of the picture in full, by scaling it down or the original size to make the picture long/wide equal to or less than the length/width of the view
Fit_center/fitcenter enlarge/Shrink the picture to the width of the view, centered on the display
Fit_end/fitend Zoom in/out to the width of the view, displayed in the lower part of the view
Fit_start/fitstart enlarge/Shrink the image to the width of the view, displayed in the upper part of the view
Fit_xy/fitxy The picture is not scaled up/down to the view size display
The Matrix/matrix is drawn with a matrix and is displayed by zooming in and out of the image.
* * To note that the Drawable folder inside the image name can not be capitalized.
--------------------------------------------------------------------------------------------------------------- ----------------------------------------------
Android:id
Specify the appropriate ID for the control
Android:text
Specify the text that appears in the control, and be aware that the string in the Strings.xml file is used as much as possible here
Android:gravity
Specifies the alignment of the view component, such as center, right, and so on, where the text position in the control is not the control itself
Android:layout_gravity
Specifies the alignment of the container component. For example, a button in the LinearLayout, you want to put the button on the left, right and other positions can be set by this property. Take button For example, android:layout_gravity= "right" button on
Android:textsize
Specifies the size of the font in the control
Android:background
Specifies the background color used by the control, and the RGB naming method
Android:width
Specifies the width of the control
Android:height
Specifies the height of the control
Android:layout_width
Specify the width of the container component
Android:layout_height
Specify the height of the container component
Android:layout_weight
Attributes that are important in view, divide space proportionally
android:padding*
Specifies the padding for the control, meaning that the contents of the control
Android:sigleline
If set to True, the contents of the control are displayed in the same row
Android:scaletype
is to control how the picture resized/moved to the ImageView siz
Android:layout_centerhrizontal
Center horizontally
Android:layout_centervertical
Center vertically
Android:layout_centerinparent
Fully centered relative to parent element
Android:layout_alignparentbottom
Snaps to the bottom edge of the parent element
Android:layout_alignparentleft
Snaps to the left edge of the parent element
Android:layout_alignparentright
Snaps to the right edge of the parent element
Android:layout_alignparenttop
Snaps to the top edge of the parent element
Android:layout_alignwithparentifmissing
If the corresponding sibling element cannot be found, then the parent element is the reference.
Android:layout_below
At the bottom of an element
Android:layout_above
At the top of an element
Android:layout_toleftof
On the left side of an element
Android:layout_torightof
On the right side of an element
Android:layout_aligntop
Aligns the top edge of this element with the top edge of an element
Android:layout_alignleft
Aligns the left edge of this element with the left edge of an element
Android:layout_alignbottom
Aligns the bottom edge of this element with the bottom edge of an element
Android:layout_alignright
Aligns the right edge of this element with the right edge of an element
Android:layout_marginbottom
The distance from the bottom edge of an element
Android:layout_marginleft
The distance from the left edge of an element
Android:layout_marginright
Distance from the right edge of an element
Android:layout_margintop
The distance from the top edge of an element
Android:paddingleft
The distance of this element from the right edge of this element
Android:paddingright
The distance of the content of this element from the top edge of this element
Android:hint
Set the prompt information in the input box when EditText is empty
Android:linearlayout
It determines the direction of the LinearLayout, whose value can be vertical, which represents the vertical layout horizontal, which represents the horizontal layout

--------------------------------------------------------------------------------------------------------------- --------------------------------------
Android:interpolator
There may be a lot of people don't understand its usage, the document is not very clear, in fact, very simple, see below: Interpolator defines the rate at which the change of an animation is made. This allows the basic animation effects (alpha, scale, translate, rotate) to be accelerated, slowed down, duplicated, etc. In a popular point of understanding is: the progress of the animation using Interpolator control. Interpolator defines the speed at which the animation changes, which can be achieved by constant velocity, positive acceleration, negative acceleration, irregular acceleration, and so on. Interpolator is a base class that encapsulates all interpolator common methods, and it has only one method, the getinterpolation (float input), which maps a point on the timeline to a M Ultiplier to is applied to the transformations of an animation. Android provides several interpolator subclasses that implement different speed curves, as follows:
Acceleratedecelerateinterpolator at the beginning of the animation and the introduction of the local rate change is slow, in the middle of the time to accelerate
Accelerateinterpolator at the beginning of the animation the rate change is slow, and then start to accelerate
Cycleinterpolator Animation Loop plays a specific number of times, rate changes along the sine curve
Decelerateinterpolator at the beginning of the animation the rate change is slow, and then start slowing down
Linearinterpolator changes at an even rate in the animation
For Linearinterpolator, the rate of change is a constant, i.e. f (x) = x.
public float getinterpolation (float input) {
return input;
}
Interpolator other sub-classes, are also in accordance with the specific algorithm, the realization of the rate of change. You can also define your own interpolator subclass to achieve the physical effects of parabolic and freefall.

TextView Property Summary

Android:autolink sets whether text is displayed as a clickable link when the text is a URL link/email/phone number/map. Selectable VALUES (None/web/email/phone/map/all)

Android:autotext if set, the spelling correction of the input values will be performed automatically. There is no effect here, it works when the input method is displayed and entered.

ANDROID:BUFFERTYPE Specifies the text category that is obtained by the GetText () method. The option editable is similar to the StringBuilder append character, which means that the Append method can be called to set the text content after gettext. Spannable can use the style in a given character area, see here 1, here 2.

Android:capitalize set the English letter capitalization type. There is no effect here, you need to pop up the input method to see, see EditView this property description.

Android:cursorvisible set cursor to show/hide, default display.

Android:digits sets which characters are allowed to be entered. such as "1234567890.+-*/% ()"

Android:drawablebottom output a drawable, slice below the text. If you specify a color, the background of text is set to that color, and the latter is overridden when used with background.

Android:drawableleft on the left side of the text output a drawable, slice.

Android:drawablepadding sets the spacing between text and drawable (picture), used with Drawableleft, Drawableright, Drawabletop, Drawablebottom, Can be set to negative, no effect is used alone.

Android:drawableright output a drawable to the right of text.

The android:drawabletop outputs a drawable directly above the text.

Android:editable whether the settings are editable.

Android:editorextras sets the additional input data for the text.

Android:ellipsize sets how the control is displayed when the text is too long. The following values are set: "Start"--the ellipsis is displayed at the beginning; End "--the ellipsis appears at the end; Middle "--the ellipsis appears in the middle; Marquee "--display in the form of a marquee (animated lateral movement)

Android:freezestext sets the contents of the saved text and the position of the cursor.

Android:gravity set the text position, as set to "center", the text will be centered.

Android:hinttext the text message that is displayed when empty, you can set the color of the hint information by Textcolorhint. This property is used in EditView, but can also be used here.

Android:imeoptions additional functions, set the action associated with the edit box in the lower right corner of the IME action, such as the lower right corner of the Actiondone will display a "done" instead of the default is a carriage return symbol. This is explained in detail in EditView, which is useless here.

Android:imeactionid Set the IME action ID.

Android:imeactionlabel Set the IME action label.

Android:includefontpadding sets whether the text contains extra white space at the top and bottom, which defaults to true.

ANDROID:INPUTMETHOD specifies the input method for text and requires a fully qualified name (the full package name). For example: Com.google.android.inputmethod.pinyin, but the error is not found here.

Android:inputtype sets the type of text that is used to help the input method display the appropriate keyboard type. Detailed in the EditView, there is no effect here.

Android:linksclickable sets whether the link clicks the connection, even if Autolink is set.

Android:marqueerepeatlimit sets the number of repetitions that are repeated when the ellipsize is specified marquee, when set to Marquee_forever.

Android:ems sets the width of the TextView to n characters. Test here for a Chinese character width

Android:maxems sets the width of the textview to a maximum of n characters. Overwrite EMS option when used with EMS.

Android:minems sets the width of the textview to a minimum of n characters. Overwrite EMS option when used with EMS.

Android:maxlength limits the length of text that is displayed, and the excess portion is not displayed.

Android:lines sets the number of lines of text, two lines are displayed, even if the second row has no data.

Android:maxlines sets the maximum number of lines of text to display, in combination with width or layout_width, beyond the partial wrap, and the number of lines beyond will not be displayed.

Android:minlines sets the minimum number of lines of text, similar to lines.

Android:linespacingextra sets the line spacing.

Android:linespacingmultiplier sets the multiple of line spacing. such as "1.2"

Android:numeric if set, the TextView has a digital input method. It is useless here, the only effect after setting is TextView has the click Effect, this property will be explained in detail in Edtiview.

Android:password with a small dot "." Display text

Android:phonenumber is set as the input for the phone number.

Android:privateimeoptions setting IME options is useless here, and will be discussed further in EditText.

android:scrollhorizontally if the text exceeds the width of the TextView, the horizontal pull bar appears.

Android:selectallonfocus If the text is selectable, let him get the focus instead of moving the cursor to the beginning or end of the text. No effect after setting in TextView.

ANDROID:SHADOWCOLOR Specifies the color of the text shadow, which needs to be used with Shadowradius.

ANDROID:SHADOWDX sets the start position of the shadow horizontal coordinates.

Android:shadowdy sets the start position of the shadow vertical coordinates.

Android:shadowradius sets the radius of the shadow. Set to 0.1 to become the color of the font, generally set to 3.0 effect is better.

Android:singleline sets the single-line display. If used with Layout_width, when the text cannot be displayed in its entirety, it is followed by "...". such as android:text= "Test_ Singleline"

Android:singleline= "true" android:layout_width= "20DP" will only show "t ...". If you do not set Singleline or set to False, the text wraps automatically

Android:text sets the display text.

Android:textappearance to set the appearance of text. As "? Android:attr/textappearancelargeinverse" here refers to the system comes with a look,? Indicates whether the system has this appearance, otherwise use the default appearance. Can textappearancebutton/textappearanceinverse/textappearancelarge/textappearancelargeinverse/ Textappearancemedium/textappearancemediuminverse/textappearancesmall/textappearancesmallinverse

Android:textcolor Setting text color

Android:textcolorhighlight the background of the selected text, the default is blue

Android:textcolorhint sets the color of the hint text, which is grayed out by default. Used in conjunction with hint.

Android:textcolorlink the color of the text link.

Android:textscalex set the spacing between text, which defaults to 1.0f.

Android:textsize set text size, recommended unit of measure "SP", such as "15SP"

Android:textstyle set glyph [Bold (bold) 0, Italic (italic) 1, bolditalic (coarse and oblique) 2] You can set one or more, with "|" Separated

Android:height Setting the height of the text area, support measurement: px (pixels)/dp/sp/in/mm (mm)

Android:maxheight Setting the maximum height of the text area

Android:minheight Setting the minimum height of the text area

Android:width sets the width of the text area, supported by the measurement: px (pixels)/dp/sp/in/mm (mm), and the difference between layout_width look here.

Android:maxwidth Setting the maximum width of the text area

Android:minwidth Setting the minimum width of the text area

Android Activity Properties Summary

Android:allowtaskreparenting

Whether to allow activity to replace dependent tasks, such as switching from a short message task to a browser task.

Android:alwaysretaintaskstate

Whether to keep the state unchanged, such as switching back to home, and then new open, the activity is in the final state

Android:cleartaskonlanunch

For example, p is activity, Q is the activity that is triggered by P, and then returns to home, the new start P, whether to show Q

Android:configchanges

Whether the onconfigurationchanged () method such as "Locale|navigation|orientation" is called when the configuration list changes.

Android:enabled

Whether the activity can be instantiated,

Android:excludefromrecents

Whether it can be displayed in the recently opened Activity list

android:exported

Whether activity is allowed to be called by other programs

Android:finishontasklaunch

Whether to close open activity when the user restarts the task

Android.icon

Android:label

Android:launchmode

Activity start mode, "standard" "Singletop" "Singletask" "SingleInstance"

One of the first two is a group, the last two are a group

Android:multiprocess

Allow multi-process

Android:name

The class name of the activity, which must be specified

Androidnhistory

Whether you need to remove this activity when the user switches to another screen. This attribute is introduced in API level 3.

Android:permission

Android:process

The name of the process in which the activity is run, and all program components run in the application's default process, which is the same name as the application's package name. The element in the process property can set a new default value for all components. But any component can override this default value, allowing you to put your program in a multi-process run. If this property is assigned the name begins with: When the activity is running, a new process dedicated to the program will be created. If the process name starts with a lowercase letter, the activity will run in the global process and be provided by its permission.

Android:screenorientation

Activity shows the mode, "unspecified" default value "Landscape" landscape mode, the width is larger than the height of "Portrait" portrait mode, height is larger than the width. "User" users ' settings "behind" "Sensor" "Nosensor"

android:statenotneeded

Whether the activity is destroyed and successfully restarted does not save the state

Android:taskaffinity

The activity's kinship, by default, has the same relationship as the activity under an application

Android:theme

Activity's style theme, if not set, the activity's theme style belongs to the application, see element's Theme property

Android:windowsoftinputmode

Interactive mode of Activity main window and soft keyboard, since API Level 3 was introduced

How the active main window interacts with the Soft keyboard window on the containing screen. The setting of this property will affect two things:

1> the state of the soft keyboard-whether it is hidden or displayed-when the activity becomes the focus of the user's attention.

2> Active main Window adjustment-whether to reduce the active main window size to make room for a soft keyboard or whether the current focus of its content is visible when part of the active window is overwritten by a soft keyboard.

It must be set to a value in the list below, or a "state ..." value plus a combination of "adjust ..." values. Set multiple values in either group-multiple "state ..." values, such as &mdash, have undefined results. Each value is separated by | Example: <activity android:windowsoftinputmode= "Statevisible|adjustresize" ... >

The value set in this (except "stateunspecified" and "adjustunspecified") overrides the value set in the topic

Value Description

The state of the "stateunspecified" soft keyboard (whether it is hidden or visible) is not specified. The system will select an appropriate state or a theme-dependent setting. This is the default setting for the software disk behavior.

The "stateunchanged" soft keyboard is maintained regardless of its last state, whether visible or hidden, when the main window appears in front.

"Statehidden" When the user chooses the activity, the soft keyboard is hidden-that is, when the user determines to navigate to the activity, instead of returning to it due to leaving another activity.

The "Statealwayshidden" soft keyboard is always hidden when the activity main window gets focus.

The "statevisible" soft keyboard is visible when that is normal (when the user navigates to the Activity main window).

"Statealwaysvisible" When the user chooses this activity, the soft keyboard is visible-that is, when the user determines that the activity is navigated to, rather than returning to it due to leaving another activity.

"Adjustunspecified" It is not specified whether the Activity main window is resized to allow space for the soft keyboard, or whether the contents of the window are visible on the screen with the current focus. The system will automatically select one of these modes primarily depending on whether the contents of the window have any layout view that can scroll their content. If there is such a view, the window will be resized so that the contents of the scrolling window can be visible in a smaller area. This is the default behavior setting for the main window.

"Adjustresize" The activity main window is always resized on the screen to allow space for the soft keyboard.

"Adjustpan" The Activity main window does not adjust the size of the screen to allow space for the soft keyboard. Instead, the contents of the current window are automatically moved so that the current focus is never covered by the keyboard and the user can always see the part of the input. This is usually not expected than resizing, because the user may turn off the soft keyboard in order to get an interactive operation with the covered content.

Android EditText Properties Summary

Android:layout_gravity= "Center_vertical"

Sets the location of the control's display: Default top, centered here, and bottom

Android:hint= "Please enter a number! "

Set up a message to display on space

Android:numeric= "Integer"

The setting can only enter integers, if it is a decimal: decimal

Android:singleline= "true"

Sets the single-line input, and once set to True, the text is not wrapped automatically.

Android:password= "true"

Set to enter password only

Android:textcolor = "#ff8c00"

Font Color

Android:textstyle= "Bold"

Font, bold, italic, Bolditalic

Android:textsize= "20dip"

Size

Android:capitalize = "Characters"

Write in uppercase letters

android:textalign= "Center"

EditText does not have this attribute, but TextView has

android:textcolorhighlight= "#cccccc"

The background of the selected text, which is blue by default

Android:textcolorhint= "#ffff00"

Sets the color of the message text, which is grayed out by default

android:textscalex= "1.5"

Control the spacing between words and words

Android:typeface= "Monospace"

Font, normal, sans, serif, monospace

Android:background= "@null"

Space background, not here, refers to transparent

android:layout_weight= "1"

Weights, which control the position between controls, are useful when controlling the size of the control display.

Android:textappearance= "? Android:attr/textappearancelargeinverse"

Text appearance, which refers to the system comes with a look,? Indicates whether the system has this appearance, otherwise the default appearance is used. I don't know if I understand that, right?

Implemented by edittext the relevant properties in the layout XML file:

1. The Password Box property android:password= "True" allows the EditText to be displayed automatically as an asterisk, and the content will be changed to * within 1 seconds.

2. Pure Digital android:numeric= "true" This allows the input method to automatically become a digital input keyboard, while allowing only 0-9 of the digital input

3. Allow only android:capitalize= "cwj1987" to accept input cwj1987 only, generally for password authentication

Here are some of the extended style attributes

Android:editable= "false" setting EditText not editable

Android:singleline= "true" forces the input to be in a single line

Android:ellipsize= "End" automatically hides trailing overflow data, typically used for long lines of text that cannot be displayed all

Relativelayout layout

android:layout_margintop= "25dip"//Top distance

Android:gravity= "left"//Space layout location

android:layout_marginleft= "15dip//Distance left margin

Relative to the given ID control

Android:layout_above the bottom of the control to the control of the given ID;

Android:layout_below Place the bottom of the control under the control of the given ID;

Android:layout_toleftof aligns the right edge of the control with the left edge of the control for the given ID;

Android:layout_torightof aligns the left edge of the control with the right edge of the control for the given ID;

Android:layout_alignbaseline aligns the baseline of the control with the baseline of the given ID;

Android:layout_aligntop aligns the top edge of the control with the top edge of the given ID;

Android:layout_alignbottom aligns the bottom edge of the control with the bottom edge of the given ID;

Android:layout_alignleft aligns the left edge of the control with the left edge of the given ID;

Android:layout_alignright aligns the right edge of the control with the right edge of the given ID;

Relative to Parent component

Android:layout_alignparenttop If true, aligns the top of the control with the top of its parent control;

Android:layout_alignparentbottom If true, aligns the bottom of the control with the bottom of its parent control;

Android:layout_alignparentleft If true, aligns the left part of the control with the left part of its parent control;

Android:layout_alignparentright If true, aligns the right part of the control with the right side of its parent control;

Center

Android:layout_centerhorizontal If True, the control is placed horizontally centered;

Android:layout_centervertical If True, the control is placed vertically centered;

Android:layout_centerinparent If True, the control is placed in the center of the parent control;

Specify moving pixels

The value of the offset on the android:layout_margintop;

Android:layout_marginbottom the value of the offset;

Android:layout_marginleft the value of the left offset;

Android:layout_marginright the value of the right offset;

Android:id---Specify the appropriate ID for the control

Android:text---The text that is displayed in the specified control, it is important to note that the string in the Strings.xml file is used as much as possible.

Android:grivity---The base position of the specified control, such as centering, right, etc. this refers to the position of the text in the control, not the control itself.

Android:textsize---The size of the font in the specified control

Android:background---Specifies the background color used by the control, and the RGB naming method

Android:width---The width of the specified control

Android:height---The height of the specified control

android:padding*---Specifies the padding for the control, meaning that the contents of the control

Android:sigleline---If set to true, the contents of the control are displayed in the same row

Below is a description of the relative layout property: Relativelayout

Android:layout_above the bottom of the control to the given ID control

Android:layout_below the top of the control to the control of the given ID

Android:layout_toleftof aligns the right edge of the control with the left edge of the control for the given ID

Android:layout_torightof aligns the left edge of the control with the right edge of the control for the given ID

Android:layout_alignbaseline the baseline of the control's baseline and the given ID of the control

Android:layout_alignbottom aligns the bottom edge of the control with the bottom edge of the given ID control

Android:layout_alignleft aligns the left edge of the control with the left edge of the given ID control

Android:layout_alignright aligns the right edge of the control with the right edge of the given ID control

Android:layout_aligntop aligns the top edge of the control with the top of the given ID control

Android:alignparentbottom if the value is true, align the bottom of the control with the bottom of the parent control

Android:layout_alignparentleft if the value is true, align the left side of the control with the left side of the parent control

Android:layout_alignparentright if the value is true, align the right side of the control with the right side of the parent control

Android:layout_alignparenttop if the value is true, aligns the top of the control with the top of the parent control

Android:layout_centerhorizontal If true, the control will be in the horizontal direction of the central

Android:layout_centerinparent If true, the control will be centered on the horizontal and vertical direction of the parent control

Android:layout_centervertical If true, the control will be in the vertical direction of the central

Android:layout_marginleft This property is used to set the gap between controls (controls and controls are different from the inside margin)

Android:padding= "3dip" indicates that the inner margin of the four edges is 3dip

Tablelayout

<tablelayout xmlns:android= "Http://schemas.android.com/apk/res/android"

android:orientation= "Vertical"

Android:layout_width= "Fill_parent"

android:layout_height= "Fill_parent"

android:stretchcolumns= "0"

></TableLayout>

android:stretchcolumns= "0" The first column fills the entire row as an extruded column

Summary of modifiers in Java:

1. Access Control modifiers

Public has the highest access level, followed by protected, default, and private

member variables and member methods can be one of 4 access levels: public, protected, default, or private

Top-level classes can be exposed or default, and top-level classes cannot be protected and private

Local variables cannot be decorated with access control modifiers

2. Abstract modifier

Abstract classes cannot be instantiated

Abstract classes can have no abstract methods, but classes that contain abstract methods must be defined as abstract methods

If a subclass does not implement all of the abstract methods in the parent class, the subclass must also be defined as an abstract class

Abstract classes cannot be defined as private, final, and static types

No abstract construction method

There is no method body for abstract methods

3. Final modifier

A class that is final decorated cannot be inherited

The method of final modification cannot overwrite the methods of the quilt class

The method of private type is assumed to be the final method and therefore cannot be overridden by the method of the Quilt class

The final variable must be explicitly initialized and can only be assigned one value at a time

4. Static modifier

Static variables have only one copy in memory and are shared across all instances of the class

Instance methods and instance variables cannot be accessed directly in a static method

The This and Super keywords cannot be used in static methods

Static methods cannot be modified by an abstract

Both static and static variables can be accessed directly through the class name

Static code blocks can only be executed once when the class is loaded. Different static method code blocks in a class are executed sequentially in the order in which they appear in the class

When multiple modifiers are connect prompt, the order of the modifiers can be reversed, but as a universally adhered programming norm, the access control modifier is usually placed first, followed by the static or Abstact modifier, followed by other modifiers

5, the following modification connect prompt use is meaningless, will lead to compile errors:

Abstract and private

Abstract and final

Abstract and static

Control properties for Android