JAVA第十课-优快云博客

本文链接：https://blog.youkuaiyun.com/aaaghvhg/article/details/148699613

跟日记本一起学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
子类中的方法...
子类中的方法...

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