面向对象第二天

最新推荐文章于 2025-08-15 22:56:20 发布

原创最新推荐文章于 2025-08-15 22:56:20 发布 · 142 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #多态 #类 #面向对象编程

本文详细介绍了Java中的面向对象特性，包括成员变量的分类、静态变量与实例变量的区别、静态方法与实例方法的调用规则。此外，还探讨了类变量（静态变量）的使用注意事项，如生命周期和调用方式。文章通过示例代码展示了静态方法与实例方法的交互，并讲解了final关键字的用法，包括修饰变量、方法和类。最后，文章阐述了Java中的继承概念，包括继承的特点、重写原则以及多态性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

面向对象第二天

成员变量的分类

变量：成员变量和局部变量

成员变量又分为类变量（静态变量）和实例变量

静态变量（类变量）：加了static修饰的成员变量

静态变量注意点：

1.静态变量是存在方法区的，只有一份！（所有对象公用）

2.静态变量是提前加载的，在new对象之前，生命周期就已经开始了

3.静态变量的调用可以使用对象调用（但是不建议），我们应该使用类名.静态变量名的方式调用
注意：静态方法中没有this也不能使用this！！！

实例变量：没有加static修饰的成员变量

静态方法：加了static修饰的方法

实例方法：没加static修饰的方法

2种方法之间的互相调用

1.静态方法中调用非静态方法（实例方法）

new对象调用

2.静态方法中调用静态方法

直接写方法名调用（本类中的调用）
类名.方法名调用（本类和其他类都可）

3.实例方法中调用静态方法

直接类名.方法名调用（本类和其他类中都可）
直接写方法名调用（本类中的调用）

4.实例方法中调用实例方法

new对象调用
直接方法名调用（仅限于本类中）

Demo1

public class Demo1 {
	int a;
    public static void main(String[] args) {
		People p1=new People();
		/*		People p2=new People();
				//p1.a=20; 静态变量可以这么调，但是不建议
				People.a=20;// 静态变量正确打开方式
				p1.b=30;	
				
				System.out.println(People.a);//20
				System.out.println(p1.b);//30
				System.out.println(People.a);//20因为是静态变量所以会共用
				System.out.println(p2.b);//0    因为是实例变量
		*/	
		
    
    }
    public static void print() {
    	System.out.println(123);
    }
    
    public void print2() {
    	System.out.println(this.a);
    	Demo1.print();
    	print3();
    	
    }
    
    public void print3() {
    	Demo1.print();
    	System.out.println(123);
    }
    
    /**
     * 静态块：提前加载
     * 静态块通常是用来提前加载图片，视频，音频等内容
     */
    static {
    	
    }
}

People

public class People {
    static int a;//静态变量
    int b;//实例变量
	
    static{
    	System.out.println("静态块");
    }
    public People() {
    	System.out.println("无参");
    }
}

Demo2

public class Demo2 {
	final static int Num=20;//静态常量
//	final int a=10; //第一种方法赋值 常用
	final int a;
	public Demo2() {//第二种方法赋值 少用
		a=30;
	}
    public static void main(String[] args) {
		Demo2 d=new Demo2();
//		System.out.println(d.a);//30
		d.print(40);//这里定的a是多少就会输出多少
	}
    public void print(final int a) {
    	//a=20;无法改变，成员变量已赋值并加了finanl
    	System.out.println(a);
    	final int b;
    	b=20;//使用之前初始化
    	System.out.println(b);
    }
}

/**
静态块：提前加载
静态块通常是用来提前加载图片，视频，音频等内容
*/

static{
    	System.out.println("静态块");
    }

final

1. final可以修饰变量
        final修饰的变量值不能被改写
2. final可以修饰成员变量和局部变量
     1. final可以修饰实例变量
        -修饰的实例变量需要在定义的同时赋值
        -修饰的实例变量也可以在构造方法中初始化
     2. final可以修饰局部变量
        -修饰的局部变量可以在定义的同时初始化
        -修饰的局部变量可以在使用之前初始化
     3. final可以修饰静态变量（常量）
          final和static同时修饰变量
          
 重点：常量的特点
    1.常量名必须大写
    2.如果是多个单词相连使用_隔开
    3.常量必须在定义的同时初始化 
    4.常量的值不能被改变
    5.常量会提前加载
    6.常量的调用是使用类名.常量名
    
3. finanl可以修饰方法
      	final修饰的方法不能被重写
4. finanl可以修饰类
   	    finanl修饰的类不能被继承

finanl是和try-catch语句块连用的，表示无论如何都会执行的代码块

变量：

成员变量，局部变量

实例变量，静态变量，类变量，常量

继承

继承：

现实生活中的继承

继承遗产

继承房产

继承皇位

继承后宫。。。

java中一旦继承，也具备别的类中的所有东西（不包含私有的）

继承使用的关键字：extends

代码

Aoo

package day09;

public class Aoo {
   private int a;//私有的
   public int b;//公共的
    
   public Aoo hobby() {
	   Aoo aoo=new Aoo();
	   System.out.println("一号女技师");
	   return aoo;
   }
}

Boo

/**
 * 
 * 此时的Boo就被成为子类，Aoo被称为父类
 *
 */
public  class Boo extends Aoo {//Boo继承了Aoo
	//子类不喜欢一号女技师 可以改变
	/**
	 * 重写了父类Aoo当中的hobby方法   父类喜欢的技师不会被干扰到
	 * 
	 * 除非加了final
	 */
	public Boo hobby() {
		   Boo boo = new Boo();
		   System.out.println("二号女技师");
		   return boo;
	 }
	
}

Coo

package day09;

public class Coo extends Aoo{

}

Test

public class Test {
    public static void main(String[] args) {
		Aoo aoo=new Aoo();
		aoo.b=20;
		aoo.hobby();
		Boo boo = new Boo();
		boo.b=30;//Boo继承了Aoo，所以也拥有Aoo类中的b变量
		
		boo.hobby();
		
        int [] arr= {10,20,30};
        arr[0]=10;
        Boo[] b=new Boo[4];
        //Boo b1=new Boo();
        //b[0]=b1;
        b[0]=new Boo();//等同于上面两句话
        Coo[] c=new Coo[4];
        c[0]=new Coo();
        //将所有的子类都统一成一个数据类型
        Aoo[] a=new Aoo[4];
        a[0]=new Boo();
        a[1]=new Coo();
        
         
	}
}

Test2

/**
 * 封装，继承，多态
 * @author 30978
 *
 */
public class Test2 {
     public static void main(String[] args) {
		Aoo aoo=new Aoo();
		aoo.hobby();//一号女技师
		Boo boo=new Boo();
		boo.hobby();//二号女技师
		/**
		 * 多态：向上造型
		 * 父类的引用指向子类的对象
		 * （父类类型的变量=子类类型的对象）
		 * 一个对象体现了可以有多种形态
		 * 
		 * 重点：能点出来什么看类型，最后执行什么看对象
		 * （主要针对向上造型）
		 */
		/*
		 * Boo boo2=new Boo();
		 *  Aoo aoo2=boo2
		 */
		
		//栈             堆
		Aoo aoo2=new Boo();//等同于上面两句话
		aoo2.hobby();//二号女技师
		Aoo aoo3=new Coo();
		aoo3.hobby();//一号女技师
		
		/**
		 * 向下造型
		 */
		//Boo boo2 =(Boo)new Aoo();
		//emmm.. 如下 这玩意可以理解为大的数据类型给小的数据类型  需要强转
		//int q=(int)10.0;
		//double qq=10;
   }
}