JAVA第十课-平芜编程栈

跟日记本一起学JAVA！相信你可以的，加油~

本课闯关内容：1.照猫画虎（0/7）

2.基础知识(0/3）

这里的基础知识的编号与照猫画虎的编号不是对应的，而是上面的基础知识对应着下面的照猫画虎代码。

有补充或者有错误我会在评论区里发或...（第七，八，九，十之后肯定有补充）

还是建议你们在电脑上看。
———————————————————————————————————————————

基础知识1：

三个修饰符

一、abstract(抽象的)

1.abstract可以用于修饰符类（规则）
（1）被abstract修饰符的类称为抽象类
语法： abstract class 类名{}
（2）抽象类编译之后生成独立的 .class 文件
（3）抽象类不能单独创建对象，但是可以声明引用
（4）抽象类中可以定义成员变量和成员方法
（5）抽象类中有构造方法，抽象类中构造方法供子类创建对象，先去完成父类对象的创建时应用。

2.abstract 可以用于修饰符方法（规则）

（1）被abstract修饰符的方法称为抽象方法
（2）抽象方法只有方法的声明部分，没有方法的实现部分(连 {} 都没有)

语法：访问修饰符 abstract 返回值类型方法名(形参列表);

例如照猫画虎1中的：
public abstract void mb();

注意：访问修饰符和 abstract 之间没有位置的先后顺序。
（3）抽象方法只能定义在抽象类中；但是抽象类中既可以有抽象方法，也可以有非抽象方法。

注意：如果子类继承抽象类，子类不想成为抽象类，则需要覆盖父类(抽象类)中所有的抽象方法，否则子类也必须定义为抽象类。

3.抽象类的作用：强制使用多态。

照猫画虎1：

package demo; public class Test1{ public static void main(String[]args){ MyClass mc =new Sub(); mc.mb(); mc.ma(); } } //抽象类 abstract class MyClass { int a=3; public void ma(){ System.out.println("ma...."); } //抽象方法：只有声明部分，没有方法的实现部分 public abstract void mb(); } //抽象类的子类 class Sub extends MyClass{ public void mb(){ System.out.println("mb...."); } }

输出：

mb....
ma....

照猫画虎2：

package demo; public class Test2{ public static void main(String[]args){ Shape[] s={ new Circle(8.9), new Rect(4,6), new Square(4.0) }; for (int i=0;i<s.length;i++){ System.out.println(s[i].arer()+"-"+s[i].girth()); } } } abstract class Shape{ public abstract double arer(); public abstract double girth(); } class Circle extends Shape{ private double r; public Circle(){}; public Circle (double r){ this.r=r; } public double arer(){ return 3.14*r*r; } public double girth(){ return 2*3.14*r; } } class Rect extends Shape{ private double a; private double b; public Rect(){}; public Rect(double a,double b){ this.a=a; this.b=b; } public double arer(){ return a*b; } public double girth(){ return 2*(a+b); } } class Square extends Rect{ private double x; public Square(double x){ this.x=x; } public double arer(){ return x*x; } public double giryh(){ return 4*x; } }

输出：

248.71940000000004-55.892
24.0-20.0
16.0-0.0

照猫画虎2中代码：

Shape[] s={
new Circle(8.9),
new Rect(4,6),
new Square(4.0)
};

显示初始化：数据类型[] 数组名 = {值1, 值2, 值3}; 应该是以此来写。

照猫画虎3：

package demo; public class Test3{ public static void main(String[]args){ MyClass mc =new MyClass(); MyClass mc2 =new MyClass(); mc.a=10; System.out.println("mc.a="+mc.a); System.out.println("mc2.a="+mc2.a); mc.b=100; System.out.println("mc.b="+mc.b); System.out.println("mc2.b="+mc2.b); System.out.println(MyClass.b); MyClass.ma(); Sub s=new Sub(); s.ma(); Sub.ma(); } } class MyClass{ int a=1;//实例变量 static int b=5;//静态变量：全类共享 public void test(){ System.out.println("成员方法"); } public static void ma(){ System.out.println("静态方法"); System.out.println("b="+b); //System.out.println("a="+a); } } class Sub extends MyClass{ public static void ma(){ System.out.println("子类中的方法..."); } }

输出：

mc.a=10
mc2.a=1
mc.b=100
mc2.b=100
100
静态方法
b=100
子类中的方法...
子类中的方法...

基础知识2：

二、static (静态的)

static可以用于修饰属性【开发应用重点】
（1）被static修饰的属性称为静态属性、静态变量、类变量
（2）语法：访问修饰符 static 数据类型属性名;

访问修饰符 static 数据类型属性名 = 值;

注意：访问修饰符和static 没有先后位置的要求。

（3）特点：静态属性是全类共有的属性，与创建多少对象没有关系。
（4）应用（语法）：
a. 对象名.静态属性名 // 不建议使用
b.类名.静态属性名 // 建议使用

static 可以用于修饰方法
(1)被 static 修饰符方法称为静态方法。
(2)语法：访问修饰符 static 返回值类型方法名(形参列表){ // 方法的实现 }

注意：访问修饰符和 static 没有位置先后要求。
(3)使用（语法）：类名.静态方法名(实参);

对象名.静态方法名(实参); // 不建议使用

（4）注意：
a.静态方法中只能直接访问本类的静态成员(静态属性和静态方法)；静态方法中不能直接访问本类的非静态的成员(非静态的属性和方法)

b.非静态方法中既可以访问本类的非静态成员(实例变量和成员方法)，也可以直接访问本类的静态的成员(静态属性和方法)

c.静态方法中不能使用 this/super关键字

d.静态方法允许被子类继承，静态方法只能被静态方法覆盖，但是没有多态的应用

注意：如果在静态方法中访问非静态成员，则可以利用创建对象，用对象名调用非静态的成员。

思考：System.out.println() ; 实现原理？？？？

System: 类名

out：静态的属性，类型为对象类型的属性 println()：方法，是out类型中的方法

2. static 可以用于修饰初始化代码块
(1)初始化代码块也被称为动态代码块
a.位置：定义类以内，方法以外的 {}
b.作用：在创建对象时，按照和属性定义先后顺序，完成对属性的初始化工作。

对象创建的过程：

分配空间：为属性赋默认值
初始化属性：为属性第二次赋值的机会 ->动态代码块执行执行构造方法：为属性第三次赋值的机会

(2)被 static 修饰的初始化代码块称为静态初始化代码块，简称静态代码块。
a.位置：定义在类以内，方法以外，同时被 static 修饰 {}
b.作用：在类加载时，按照和静态属性定义的先后顺序，完成对静态属性的初始化工作。
c.类加载：
i.概念：当JVM第一次使用一个类的时候，通classPath(类路径)找到对应的.class文件，从.class文件中读取该类的信息(包、类名、父类、属性、成员方法、构造方法等)，读取之后将信息存储在 JVM内存中，一个类只进行一次类加载。

ii.类加载时机(什么情况会导致一个类进行类加载)：

1.第一次创建该类对象：先进行类加载，再完成对象的创建
2.第一次使用该类的静态成员(静态属性和静态方法)：会进行类加载
3.子类的类加载会导致其父类先进行类加载：先加载其父类，再加载子类

-> 第一次调用子类中的静态成员：先加载其父类，再加载子类

-> 第一次创建子类对象：先加载，再完成对象的创建：
带有类加载创建对象的过程：

先加载：先加载其父类，再加载子类

先加载父类：为父类的静态属性分配空间并完成父类静态属性的初始化

--->父类的静态代码块被执行

再加载子类：为子类的静态属性分配空间并完成子类静态属性的初始化 --->子类的静态代码块被执行

在完成对象的创建：先创建父类对象，再子类对象
先完成父类对象的创建：

初始化父类的属性：--->父类的动态代码块被执行执行父类的构造方法再完成子类对象的创建：初始化子类的属性：--->子类的动态代码块被执行执行子类的构造方法

注意：只声明引用不会导致类加载。

3. static 可以用于修饰内部类

照猫画虎4：

package demo; public class Test4{ public static void main(String[]args){ //MyClass mc = new MyClass(); //System.out.println(MyClass.b); //MyClass mc = new MyClass(); //System.out.println(Sub.n); Sub s=new Sub();// 11 33 22 44 先加载（先父类后子类）-》完成对象的创建（先父类 后子类） } } class MyClass{ int a=3; static int b=5; static{ System.out.println ("静态代码块..11"); b=30; } public MyClass(){ System.out.println("构造方法..22"); } } class Sub extends MyClass { int m=30; static int n=50; static{ System.out.println("静态代码块..33"); b=300; } public Sub(){ System.out.println("构造方法..44"); } }

输出：

静态代码块..11
静态代码块..33
构造方法..22
构造方法..44

照猫画虎5：

package demo; public class Test5{ public static void main(String[]args){ MyClass mc1 = new MyClass(); MyClass mc2 = new MyClass(); MyClass mc3 = new MyClass(); MyClass mc4 = new MyClass(); System.out.println("创建对象的个数："+MyClass.count); } } //统计对象创建的个数 class MyClass{ static int count; public MyClass (){ count++; } }

输出：

创建对象的个数：4

基础知识3：

三、final(最终的、最后的)

变量(局部变量、实例变量、静态变量)

(1) final修饰的变量是作用范围内的常量，只允许一次赋值，不允许更改，可以多次被使用。 (2) final的实例变量不再分配默认值，为其初始化的时机：

a.声明的同时对其初始化
b.在构造方法中对其初始化，但是必须保证每一个构造方法都对其从初始化
c.借助动态代码块对其初始化

(3) final 修饰的静态属性不再分配默认值，为其初始化的时机：

a.声明的同时对其初始化
b.借助静态初始化代码块对其初始化

注意：final 修饰的引用，代表引用中存储对象的地址不能改变。

2.final 可以用于修饰方法：可以被子类继承，但是不允许被覆盖。

3.final 可以用于修饰类：被final修饰的类不能被继承，即没有子类。例如：String / System / Math 等。

照猫画虎6：

package demo; public class Test6{ public static void main(String[]args){ final int a=5; //a=20 System.out.println(a); System.out.println(a+8); System.out.println(a); final MyClass mc=new MyClass(); //mc =new MyClass(); mc.a = 100; Sub s = new Sub(); s.ma(); } } class MyClass{ int a=8; public final void ma(){ System.out.println("ma..."); } } class Sub extends MyClass { }

输出：

5
13
5
ma...

照猫画虎7：

package demo; public class Make{ public static void main(String[]args){ MyClass mc =new MyClass(); MyClass mc2 =new MyClass(); System.out.println("mc.a="+mc.a); System.out.println("mc2.a="+mc2.a); System.out.println("mc.b="+mc.b); System.out.println("mc2.b="+mc2.b); System.out.println(MyClass.b); MyClass.ma(); Sub s=new Sub(); s.ma(); Sub.ma(); } } class MyClass{ int a=1;//实例变量 static int b=5;//静态变量：全类共享 public void test(){ System.out.println("成员方法"); } public static void ma(){ System.out.println("静态方法"); System.out.println("b="+b); //System.out.println("a="+a); } } class Sub extends MyClass{ public static void ma(){ System.out.println("子类中的方法..."); } }

输出：

mc.a=1
mc2.a=1
mc.b=5
mc2.b=5
5
静态方法
b=5
子类中的方法...
子类中的方法...

跟我一步步学，慢慢走。
未完待续。。。