Java阶段二- 封装、static关键字（静态）、继承

谁践踏了优雅 2023-10-04 09:46 20阅读 0赞

## 面向对象的封装特性和static关键字 ##

(1)封装  
(2)static关键字  
(3)继承

#### 1.封装(重中之重 20遍) ####

**1.1 基本概念**  
通常情况下测试类可以对封装类中的成员变量进行赋值，若赋值的数据合法但不合理时，无论时编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活不符。  
为了避免上述错误的发生，就需要对成员变量进行密封包装处理，该机制就叫做封装，换句话说，封装就是一种保证成员变量值合理性的机制。

**1.2 实现流程**  
(1)私有化成员变量，使用private关键字修饰；  
(2)提供公有的get和set方法，在方法体中进行合理值的判断；  
(3)在构造方法中调用set方法进行合理值的判断；

/*编程实现Car类的封装*/
    public class Car1
    {
           //特征
    	//私有化成员变量，使用private关键字修饰
    	//private修饰成员变量表示私有的含义，改成员变量只能在本类的内部使用
    	private String brand;
    	private String color;
    	private int price;
    	//在构造方法中调用set方法进行合理值的判断
    	//无参构造
    	public Car1(){
        }
    	//三个参数的构造
    	public Car1(String brand,String color,int price){
        
    			//this.brand=brand;
    			//this.color=color;
    			//this.price=price;
    			setB(brand);
    			setC(color);
    			setP(price);
    
    	}
    	//打印所有特征的行为
    	public void show(){
        
    		//System.out.println("品牌："+brand+"颜色："+color+"价格："+price);
    		//修改后提高了代码的可用性，可维护性
    
    		System.out.println("品牌："+getB()+"，颜色："+getC()+",价格："+getP());
    	}
    	
    	//提供共有的get和set方法，并在方法体中进行合理值的判断
    	//public修饰成员方法表示共有的，该方法可以在任意位置调用
    	//获取品牌并返回的行为
    	public String getB(){
        
    		return brand;
    
    	}
    	public String getC(){
        
    		return color;
    	}
    	//获取价格并返回的行为
    	public int getP(){
        
    		return price;
    	}
    	//设置品牌为参数指定的数值
    	public void setB(String x){
        
    		this.brand=x;
    	}
    	//设置颜色为参数指定的数值、
    	public void setC(String y){
        
    		this.color=y;
    	}
    	//设置价格为参数指定的数值、
    	public void setP(int z){
        
    		if (z>=0)
    		{
        
    			this.price=z;
    		}else{
        
    			System.out.println("价格不合理！！！！");
    		}
    	}
    	//实现价格增长1000元的行为、
    	public void setP(){
        
    			price+=1000;
    	}
    
       //实现价格增长参数指定数值的行为
        public void setP1(int a){
        
    			this.price+=a;
    	}
    
    
    	public static void main(String[] args){
        
    		Car1 tt=new Car1();
    		tt.show();
    		Car1 tt1=new Car1("SF90","yellow",4900000);
    		tt1.show();
    		System.out.println("-------------------------");
    		String ia=tt1.getB();
    		System.out.println("车的品牌为："+ia);
    		String ib=tt1.getC();
    		System.out.println("车的颜色为："+ib);
    		int ic=tt1.getP();
    		System.out.println("车的价格为："+ic);
    		System.out.println("-------------------------");
    		tt1.setB("BMW");
    		tt1.show();
    		tt1.setC("red");
    		tt1.show();
    		tt1.setP(-5000000);//价格负数在没有封装前是没有判断的，封装后会有提示。
    		tt1.show();
    		System.out.println("-------------------------");
    		tt1.setP();
    		tt1.show();
    		System.out.println("-------------------------");
    		tt1.setP1(-50000);
    		tt1.show();
    		Car1 c3 = new Car1("奥迪Q3", "白色", -400000);
            c3.show(); // 奥迪Q3 白色 400000
    	}
    }

2.static关键字(重点)  
2.1 基本概念  
通常情况下成员变量隶属于对象层级，每创建一个对象就需要申请独立的内存空间来存放该对象独立的成员变量信息，若所有对象的某个成员变量数值完全一样却又单独存放会造成内存空间的浪费。  
为了解决上述问题，则使用static关键字修饰成员变量表达静态的含义，此时该成员变量由对象层级提升为类层级被所有对象共享，该成员变量随着类的加载准备就绪，与是否创建对象无关。  
static关键字也可以修饰成员方法，推荐使用 类名. 的方式访问。

2.2 使用方式  
(1)在非静态的成员方法中既能访问非静态的成员也能访问静态的成员；  
(成员：成员变量 + 成员方法， 静态成员被所有对象共享)  
(2)在静态的成员方法中只能访问静态的成员不能访问非静态的成员；  
(成员：成员变量 + 成员方法， 调用静态方法时可能还没有创建对象)  
(3)只有隶属于类层级被所有对象共享的内容才可以使用static修饰；  
(不能滥用static关键字)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70]

static的属性/方法在类加载时就已经做好准备，因此类名.就可以调用，与对象存在不存在无关。  
非static的属性/方法隶属于对象，必须先创建对象，才能使用。  
static的方法中，不能使用非静态的属性或者方法，必须先创建对象，然后用对象.调用；  
static方法的作用在于提供一些“工具方法”和“工厂方法”。”  
而非static的方法中，可以直接使用静态的属性或方法  
只有隶属于类(所有对象共享)的属性才能加static，static不能随便加。

//编程实现static关键字的使用
    
    
    public class StaticTest
    {
        
    	private int cnt=1;//隶属于对象层级，每个对象都拥有一份 
    	private static int snt=2;//隶属于类层级，所有对象共享同一份
    
    
    	//下面的方法没有static修饰，隶属于对象层级
    	public void show(){
        
    		System.out.println("cnt ="+cnt);
    		System.out.println("snt="+snt);
    	}
    	//使用static修饰的方法的方法隶属于类层级，推荐使用类名.的方式
    	public static void test(){
        
    		System.out.println("snt ="+snt);
    	
    	}
    
    	//使用static修饰的方法的方法隶属
    	public static void main(String[] args){
        
    
    
    		//static的属性/方法在类加载时就已经做好准备，因此类名.就可以调用，与对象存在不存在无关。
    		StaticTest.test();
    
    		//非static的属性/方法隶属于对象，必须先创建对象，才能使用。
    		StaticTest st=new StaticTest();
    		st.show();	
    	}
    }

案例：  
编程实现Singleton类的封装；  
编程实现SingletonTest类对Singleton类进行测试，要求在main方法中能得到且只能得到Singleton类的一个对象。

/*
       1:编程实现Singleton类的封装；
    */
    
    
    public class Singleton
    {
        
    	//2:提供本类类型的引用指向本类类型的对象
    	//成员变量
    	//static成员变量变成类变量
    	//封装，成员变量私有化
    	private static Singleton sin=new Singleton();
    
    
    
    	//1:私有化构造方法，使用Private关键字修饰
    	//private修饰构造方法，表示该方法只能在本类的内部使用
    	private Singleton(){
        }
    
    
    
    	//3:提供公有的get方法负责将成员变量返回出去
    	public static Singleton getInstance(){
        
    		return sin;
    	}
    }

/*
    2:编程实现SingletonTest类对Singleton类进行测试，要求在main方法中能得到且只能得到Singleton类的一个对象。
    */
    
    
    public class SingletonTest
    {
        
    
    	public static void main(String[] args){
        
    			//声明Singleton类型的引用指向该类型的对象
    			//调用Singleton类的无参构造
    			//在堆区和栈区中分别申请两块内存地址
    			
    			/*
    			Singleton s1 =new Singleton();
    
    			Singleton s2 =new Singleton();
    			System.out.println(s1==s2);//判断s1的数值是否与s2相等,false不是同一个对象
    
    			*/
    			//要求在main方法中能得到且只能得到Singleton类的一个对象。
    			Singleton s1=Singleton.getInstance();
    			Singleton s2=Singleton.getInstance();
    			System.out.println(s1==s2);//true调用的是同一个对象
    
    	}
    }

运行：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 1]  
2.3 单例设计模式(重中之重 20遍)  
(1)基本概念  
在某些特殊场合中一个类对外提供且只提供一个对象，这样的类叫做单例类。  
而设计单例类的思想和模式叫做单例设计模式，主要用于固定的场合。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 2]

(2)实现流程  
a.私有化构造方法，使用private关键字修饰；  
b.声明本类类型的引用指向本类类型的对象，使用private static共同修饰；  
c.提供公有的get方法负责将成员变量的数值返回出去，使用static关键字修饰；

(3)实现方式  
单例设计模式的实现方式有两种：饿汉式 和 懒汉式，在以后的开发中推荐饿汉式。

/*
       1:编程实现Singleton类的封装；
    */
    
    
    public class Singleton
    {
        
    	//2:提供本类类型的引用指向本类类型的对象
    	//成员变量
    	//static成员变量变成类变量
    	//封装，成员变量私有化
    	private static Singleton sin=new Singleton();//饿汉式
    	private static Singleton sin=null;//懒汉式
    
    
    
    	//1:私有化构造方法，使用Private关键字修饰
    	//private修饰构造方法，表示该方法只能在本类的内部使用
    	private Singleton(){
        }
    
    	//3:提供公有的get方法负责将成员变量返回出去
    	public static Singleton getInstance(){
        
    		//return sin;
    		if (null==sin)
    		{
        
    			sin=new Singleton();
    		}
    		return sin;
    	}
    }

插入：构造块和静态代码块

/*
    编程实现构造块和静态代码块的认识和使用
    */
    public class TestStaticBlock
    {
        //静态代码块先于构造块执行
    
    	//在类体里面我们直接用{}括起来我们就称之为构造块
    	{
        
    			System.out.println("构造块");
    	}
    	//在{}前加上static就是静态代码块
    	static{
        
    		System.out.println("这就是静态代码块，随着来的加载执行一次");
    	}
    	public TestStaticBlock(){
        
    	
    			System.out.println("构造方法体~~~无参构造");
    	}
    	public static void main(String[] args){
        
    			TestStaticBloak tsb =new TestStaticBlock();
    	}
    }

3.继承(重中之重)  
人类：  
特征：姓名、年龄  
行为：吃饭、娱乐  
学生类 吸收 人类：  
特征：学号  
行为：学习  
教师类 吸收 人类：  
特征：工号  
行为：讲课  
工人类 吸收 人类：  
特征：薪水  
行为：工作  
…

3.1 基本概念  
当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成一个公共类，让多个类吸收公共类中已有特征和行为而在多个类的内部编写自己独有特征和行为的方式，叫做继承。  
使用继承可以提高代码的复用性和扩展性以及可维护性。  
在Java语言中使用extends(扩展)关键字来表达继承关系。  
如：  
public class Student extends Person \{\} - 表示Student类继承自Person类  
其中Person类叫做基类、父类、超类  
其中Student类叫做派生类、子类、孩子类

搞定！！！  
坏人永远都会有，但是遇到了坏人我们不能怕他们！！！  
今天有感受到：  
没有人是完美的，也包括我自己，如果对一件事情尽了最大的努力，那就心平气和的接受吧！！！共勉  
一步一步提升，稳赢！！！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210401005217641.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210401082731396.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210401090137400.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NjU2MDc3,size_16,color_FFFFFF,t_70