Introduction of today's content
U Knowledge Review
U static keyword
U code block
Chapter 1th Knowledge Review
1.1 Review of methods
1.1.1 Case Code One:
Package com.itheima_01;
/*
* Requirements: Define a method to calculate the number of two and invoke it in the Main method
*
* Method: A program with a specific function in the class, which improves the reusability and maintainability of the code.
* Definition Format:
* public static return value type (no return value write void) method name (parameter type parameter name, parameter type argument name 2) {//formal parameter
* Method body;
* }
* Call Mode:
* There is a definite return value type:
* Assignment call to assign the return value of a method to a variable
* Output calls, using output statements to output the method's return value directly
* Direct call, unable to get the return value of the method
* No explicit return value type:
* Direct Call
* Method Overloading: There are multiple methods with the same name in a class, with different parameters, independent of the return value
*
Note
* Parameter: A variable declared by a method, only a variable, the data passed in when the method call is received
* Arguments: The data that is passed when the method is called, can be a constant, or it can be a variable
*
*/
public class Methodemo {
public static void Main (string[] args) {
Assignment invocation
int sum = SUM (10,20);//argument
SYSTEM.OUT.PRINTLN (sum);
Output call
int a = 10;
int B = 20;
System.out.println (sum (A, b));
}
public static int sum (int a,int b) {
/*//Use variable to receive sum result and return
int sum = a + b;
Return sum;*/
Return the sum result directly
return a + B;
}
}
1.2 Review of arrays
1.2.1 Case code Two:
Package com.itheima_02;
/*
* Requirements: Define an array of element type int, iterate over the array and sum
*
* Array: A container for storing multiple elements
* Features of the array:
* element types must be consistent
* element has an integer index
* Once defined, the length cannot be changed.
* Basic data types can be stored
* Reference data types can also be stored
* Definition Format:
* Dynamic Initialization
* element type [] Array name = new element type [10];
* Static Initialization
* element type [] Array name = {element 1, element 2, element 3};
* element type [] Array name = new element type []{element 1, Element 2, element 3};
*
*/
public class Arraydemo {
public static void Main (string[] args) {
Defining an array with static initialization
Int[] arr = {1,2,3,4,5};
Define a variable to store the sum result
int sum = 0;
Iterating through an array
for (int x = 0;x < arr.length;x++) {
Sum + = arr[x];
}
SYSTEM.OUT.PRINTLN (sum);
}
}
1.3 Standard class definition and usage review
1.3.1 Case Code Three:
Package com.itheima_03;
/*
* Define a standard student class, create an object in the main method, and invoke the
* Name, age, gender 3 member variables
* No reference, two methods of construction
* Define the Getter/setter method for each member variable
* Define a Show method, output member variable
*/
public class Student {
Private String name;//Name
private int age;//Age
Private String gender;//Sex
/*//Non-parametric structure
Public Student () {}
With a reference structure
Public Student (String name,int age,string gender) {
THIS.name = name;
This.age = age;
This.gender = gender;
}
Name
Public String GetName () {
return name;
}
public void SetName (String name) {
THIS.name = name;
}
Age
public int getage () {
return age;
}
public void Setage (int.) {
This.age = age;
}
Gender
Public String Getgender () {
return gender;
}
public void Setgender (String gender) {
This.gender = gender;
}*/
Show: Used to output all the member variables
public void Show () {
SYSTEM.OUT.PRINTLN (name + "," + Age + "," + gender ");
}
Public Student () {
Super ();
TODO auto-generated Constructor stub
}
Public Student (string name, int age, string gender) {
Super ();
THIS.name = name;
This.age = age;
This.gender = gender;
}
Public String GetName () {
return name;
}
public void SetName (String name) {
THIS.name = name;
}
public int getage () {
return age;
}
public void Setage (int.) {
This.age = age;
}
Public String Getgender () {
return gender;
}
public void Setgender (String gender) {
This.gender = gender;
}
}
Package com.itheima_03;
public class Studenttest {
public static void Main (string[] args) {
Create Student objects
Student s = new Student ();
Assigning values to member variables
S.setname ("Zhang San");
S.setage (18);
S.setgender ("male");
S.show ();
System.out.println ("----------");
Student s2 = new Student ("John Doe", 20, "other");
S2.show ();
System.out.println (S2.getname ());
}
}
2nd static statically key word
2.1 Overview of the static
When you define a class, you have the appropriate properties and methods in the class. The properties and methods are called by creating this class of objects. When a method of an object is called, the method does not have access to the object's unique data, and the method creates the object somewhat superfluous. But do not create the object, the method can not be called, then you will think, then we could not create the object, we could call the method?
Yes, we can do that by using the static keyword. static modifier, which is typically used to decorate a member of a class.
2.2 Static characteristics
A: The static modified member variable belongs to the class and does not belong to an object of this class. (That is, when multiple objects access or modify a static decorated member variable, one of the objects modifies the value of the static member variable, and the value of the static member variable in the other object changes, that is, multiple objects share the same static member variable)
B: Members that are modified by static can and recommend direct access through the class name
To access the format of a static member:
Class name. static member Variable name
Class name. Static member Method name (parameter)
C: Static loading takes precedence over objects and loads as classes are loaded
2.2.1 Case Code IV
Package com.itheima_01;
/*
* Static: is a keyword used to modify member variables and member methods
* Characteristics of static:
* Shared by all objects
* Can be called using the class name
* Static loading takes precedence over objects
* Loaded with the load of the class
*
*/
public class Staticdemo {
public static void Main (string[] args) {
Person.graduatefrom = "School of transfer of Wisdom";
Person p = new person ();
P.name = "Xiao Cang classmate";
P.age = 18;
P.graduatefrom = "School of transfer of Wisdom";
P.speak ();
person P2 = new person ();
P2.name = "wavelet classmate";
P2.age = 20;
P2.graduatefrom = "School of transfer of Wisdom";
P2.speak ();
}
}
Class Person {
String name;
int age;
Static String Graduatefrom;//graduated college
public void Speak () {
SYSTEM.OUT.PRINTLN (name + "---" + graduatefrom);
}
}
2.3 Static considerations
A: Static members can only access static members directly
B: Non-static members can access both non-static members and static members
2.3.1 Case Code Five
Package com.itheima_01;
/*
* Static Considerations:
* Static method:
* Static member variables can be called
* Static member methods can be called
* Non-static member variables can not be called
* Non-static member methods can not be called
* Static methods can only invoke static members
* Non-static method:
* Static member variables can be called
* Static member methods can be called
* Non-static member variables can be called
* Non-static member methods can be called
*
* Do you have this object in the static method? No, No.
*
*
*/
public class StaticDemo2 {
public static void Main (string[] args) {
Student.graduatefrom = "School of transfer of Wisdom";
Student.study ();
}
}
Class Student {
String name;
int age;
Static String Graduatefrom;//graduated college
public static void study () {
System.out.println (Graduatefrom);
Sleep ();
SYSTEM.OUT.PRINTLN (name);
Eat ();
}
public static void Sleep () {
System.out.println ("Sleep");
}
public void Eat () {
System.out.println ("eat");
System.out.println (Graduatefrom);
Sleep ();
}
}
2.4 Advantages and disadvantages of static
A: Static Advantages:
Shared data on objects provides a separate space for storage, saving space, without the need for each object to store a copy
Can be called directly by the class name without creating an object in heap memory
Static members can be accessed directly through the class name, making it easy to access the members relative to the object
B: Static drawbacks:
The limitations of access occur. (Static although good, but only static)
2.5 Static applications
The 2.5.1 Math class uses
The A:math class contains methods for performing basic mathematical operations. Classes commonly used in mathematical operations.
The constructor method of the B:math class is private, unable to create the object, and cannot access the members of the math class through the object.
All members of the C:math class are statically decorated, so we can access them directly from the class name.
2.5.1.1 Case Code Three:
Package com.itheima_02;
public class Mathdemo {
public static void Main (string[] args) {
Math: Contains some basic mathematical methods
Static Double PI
System.out.println (Math.PI);
Static double abs (double A): return absolute value
System.out.println (Math.Abs (15)); 15
System.out.println (Math.Abs (-10)); 10
Static double Ceil (double A) ceiling upward rounding
System.out.println (Math.ceil (1.2)); 2
System.out.println (Math.ceil (1.6)); 2
System.out.println (Math.ceil (-1.6));-1
Static double floor (double a) flooring is rounded down
System.out.println (Math.floor (1.2)); 1
System.out.println (Math.floor (1.6)); 1
System.out.println (Math.floor (-1.6));-2
Static Long round (double a): rounding
System.out.println (Math.Round (1.2)); 1
System.out.println (Math.Round (1.6)); 2
Static Double Max (double A, double b)
System.out.println (Math.max (3, 4)); 4
Static Double pow (double A, double b): Returns the second argument of the first argument to the power of a
System.out.println (Math.pow (3, 2)); 8
static double Random (): Returns a random number greater than 0 and less than one
System.out.println (Math.random ());
}
}
2.5.2 Custom Tool Classes
A: Requirements: Customize a tool class that specializes in array operations, with the following features
1. Define a method that can return the largest element in the array
2. Define a method that finds out if the value exists in the array, based on the specified value
exists, returns the index of the value in the array
Not present, return-1
2.5.2.1 Case Code Four:
Package com.itheima_03;
public class Myarrays {
Private Myarrays () {}
/*
* Returns the largest element in the array
*
*/
public static int Getmax (int[] arr) {
int max = 0;//referential
Iterating through an array
for (int x = 0;x < arr.length;x++) {
if (Arr[x] > max) {
max = arr[x];//Replacement Reference
}
}
return Max;
}
/*
* Returns the index of the specified parameter in the array
*
*/
public static int GetIndex (int[] Arr,int a) {
Iterating through an array
for (int x = 0;x < arr.length;x++) {
if (arr[x] = = a) {
return x;
}
}
return-1;//If no parameters are found, return-1
}
}
Package com.itheima_03;
public class Myarraysdemo {
public static void Main (string[] args) {
Int[] arr = {3,5,8,10,1};
int max = Myarrays.getmax (arr);
SYSTEM.OUT.PRINTLN (max);
int index = Myarrays.getindex (arr, 8);
SYSTEM.OUT.PRINTLN (index);
}
}
Analysis of 2.6 class variables and instance variables
A: Class variable: It's actually A static variable.
Define location: Outside the method in the class
Area of Memory: Method area
Life cycle: Loaded as the class loads
Features: No matter how many objects are created, class variables are only in the method area, and only one copy
B: Instance variable: It's actually a non-static variable.
Define location: Outside the method in the class
Area of Memory: Heap
Life cycle: Loaded as objects are created
Features: Each object is created and there is an instance variable in the object in the heap
3rd Chapter code block
3.1 Local code block
A local code block is defined in a method or statement
3.1.1 Case Code VI:
public class Blockdemo {
public static void Main (string[] args) {
Local code block: The Life cycle (scope) of the control variable that exists in the method
{
for (int x = 0;x < 10;x++) {
System.out.println ("I love Java");
}
int num = 10;
}
SYSTEM.OUT.PRINTLN (num);//cannot access num beyond the scope of NUM
}
}
3.2 Building Code Blocks
Constructing a code block is a block of code that defines the position of a member in a class
3.2.1 Case Code VII:
Package com.itheima_04;
Class Teacher {
String name;
int age;
{
for (int x = 0;x < 10;x++) {
System.out.println ("I love Java");
}
System.out.println ("I love Java");
}
Public Teacher () {
System.out.println ("I am a non-parametric structure");
}
Public Teacher (String Name,int age) {
System.out.println ("I am a constructive");
THIS.name = name;
This.age = age;
}
}
3.3 Static code block
A: A static code block is a block of code that is defined at the member location, using the static adornment
3.3.1 Case Code Eight:
Class Teacher {
String name;
int age;
Static code blocks: loaded as the class loads, loading only once, and some initialization needed to load the class, such as loading the driver
static {
System.out.println ("I love Java");
}
Public Teacher () {
System.out.println ("I am a non-parametric structure");
}
Public Teacher (String Name,int age) {
System.out.println ("I am a constructive");
THIS.name = name;
This.age = age;
}
}
3.4 Features of each code block:
3.4.1 Local code block:
A region of code delimited with "{}", at which point you only need to focus on the different scopes
Methods and classes delimit boundaries in a code block way.
3.4.2 Constructing code blocks
Takes precedence over construction method execution, and constructs code blocks to perform initialization actions that are required for all objects
Each object that is created executes a block of construction code at a time.
3.4.3 Static code block
It takes precedence over the execution of the Main method, which takes precedence over the construction of code block execution, when used in any form for the first time to the class.
The static code block executes only once, regardless of how many objects are created.
Can be used to assign a value to a static variable for initialization of a class.
3.4.4 Case Code IX:
Package com.itheima_04;
/*
* Coder Static code block execution---Coder Construction code block execution---Coder null-free construction execution
*
*
* Blocktest static code block execution---Blocktest of the main function performed---Coder Static code block execution---Coder construct code block execution---coder NULL structure execution
* Coder Construction code block execution---Coder null-free construction execution
*
*/
public class Blocktest {
static {
System.out.println ("blocktest Static code block execution");
}
{
SYSTEM.OUT.PRINTLN ("Blocktest Construction Code block execution");
}
Public Blocktest () {
System.out.println ("Blocktest without a reference structure");
}
public static void Main (string[] args) {
SYSTEM.OUT.PRINTLN ("The main function of the blocktest executes");
Coder C = new coder ();
Coder C2 = new Coder ();
}
}
Class Coder {
static {
System.out.println ("Coder Static code block execution");
}
{
SYSTEM.OUT.PRINTLN ("Coder Construction Code block execution");
}
Public Coder () {
SYSTEM.OUT.PRINTLN ("Coder Non-parametric construction execution");
}
}
Java Learning-Basic knowledge advanced first day--static static keywords, code blocks