0
点赞
收藏
分享

微信扫一扫

JAVA基础05—面向对象

西特张 2022-02-16 阅读 43
java开发语言后端

文章目录

前言

本文为个人学习、复习过程中的笔记整理而来，适合读者快速入门与快速回顾。

文章目录

一、类与对象

1.1 类

一个class就是一个类。一个类创建对象 就是我们常用的new对象

1.2 引用类型

JAVA中的数据类型除了八大基本类型，还有引用类型。

什么是引用呢？

如果一个变量的类型是一个类，那么该变量就是一个引用。也可以说这个变量指向一个类。
引用类型指一个变量的数据类型是一个类。

基本类型的封装类型其实也是引用类型。

引用的概念比较重要，有空多查询、消化理解。

package BasicDemo07_ClassAndObject;
/**
 * This class is used to test 
 * @author Sharry
 * 用于学习
 * */
public class Dragon {

	//Attributes
	private int blood;
	
	private String attack;
	
	//Method
	public void eat() {
		System.out.println("Eating");
	}

	public static void main(String[] args) {
	    //创建对象
	    new Dragon();
		 
	    //引用指向这个新创建的对象
		Dragon d1 = new Dragon();
		 
		System.out.println(d1);
		
		//引用指向的测试
		Dragon d2 = new Dragon();
		Dragon d3 = new Dragon();
		Dragon d4 = d2;
		Dragon d5 = d3;
		
		//Dragon d4 = d3;
		//此处不合法，只能指向一个对象
		
		System.out.println(d2);
		System.out.println(d4);
		
	}
}

1.3 类的继承

继承是面向对象三大特性之一。继承提高了代码复用性。

JAVA是单继承，一个类只能有一个父类。

public class Father {
    //Define attribute
    int age;
    String name;
    //Define method
    public void action(){
        System.out.println("I am super class");
    }
}

class Son extends Father{
    public void action(){
        System.out.println("I am son class");
    }
}

class test {
    public static void main(String[] args){
        Son son = new Son();
        son.age = 1;
        son.name = "2B";
        son.action();
    }

注意的是，当父类有类方法，即static 修饰的方法时，子类就会隐藏该方法。static修饰的方法可以通过类名直接点出来，下面是例子:

public class HideMethodFather {

	//Attributes
	private int age;
	private String name;
	
	//类静态方法
	public static void eat() {
		System.out.println("Father is eating");
	}

}
public class HideMethodSon
//Attributes 
    private int sonNum;
    
    //Hide method
    public static void eat() {
    	System.out.println("Son is eating");
    }
	
    
    public static void main(String[] args) {
		HideMethodFather.eat();
		HideMethodSon.eat();
	}

1.4 访问修饰符

public class Review_Jurisdiction {

	int Num;
	//什么都不修饰——友好型
	
	public String Name;
	//公共属性
	
	private String Wife;
	//私有属性
	
	protected long length;
	//保护属性
	
	void Firendly(){
		System.out.println("测试一下友好方法");
		
	}
	//友好方法
	public void Methodtest_01(){
		System.out.println("测试一下公共方法");
		
	};
	//公共方法
	
	private void Methodtest_02() {
		System.out.println("测试一下私有方法");
		
	}
	
	//私有方法
	protected void Method_03() {
		System.out.println("测试一下保护的方法");
		
	}
	//保护方法
}

修饰符的访问权限表:

修饰符同一个类同一个包不同包的子类不同包的非子类
private√
default√√
protected√√√
public√√√√

1.5 构造方法

通过一个类创建一个对象，这个过程叫做实例化

实例化是通过调用构造方法(又叫做构造器)实现的。

我们可以通过有参构造给对象传参。

构造方法的语法规则:方法名=类名，没有返回值。

public class Monster {

	//攻击力
	private int attackPower;
	//防守力
	private int defendPower;
	//星数
	private int starLevel;
    
    //效果
	private String funtion;
    
    //动作
    public String attack() {
    	return "Attacking!";
    }

    //构造方法
	public Monster(int attackPower, int defendPower, int starLevel, String funtion) {
		super();
		this.attackPower = attackPower;
		this.defendPower = defendPower;
		this.starLevel = starLevel;
		this.funtion = funtion;
	}

	public Monster() {
		//无参构造，此处的super调用的是父类Object 的方法。万物皆对象！
		super();
	}
}

当没有在该类上写任何构造方法时，默认有一个无参构造。当我们写了构造方法以后，默认会覆盖掉原有的无参构造。

1.6 方法的重载、重写

JAVA中，重名的方法有两个概念:重载和重写。

重载通常发生在同一个类中，表示方法名相同，参数不同。

重写通常发生在继承关系中，表示子类将父类同名方法进行重写。

1.6.1 重载

Overload,指方法名相同，参数不同。提高了代码的复用性。

//super关键字，调用父类方法
		public void testSuper() {
			super.attack();
		}
		
		//方法的重载
		public void testSuper(int j) {
			System.out.println(j);
		}

1.6.2 重写

public class Monster {

	//攻击力
	private int attackPower;
	//防守力
	private int defendPower;
	//星数
	private int starLevel;
    
    //效果
	private String funtion;
    
    //动作
    public String attack() {
    	return "Attacking!";
    }

    //构造方法
	public Monster(int attackPower, int defendPower, int starLevel, String funtion) {
		super();
		this.attackPower = attackPower;
		this.defendPower = defendPower;
		this.starLevel = starLevel;
		this.funtion = funtion;
	}

	public Monster() {
		//无参构造，此处的super调用的是父类Object 的方法。万物皆对象！
		super();
	}
}

class BlueEyesWhiteDragon extends Monster{
	
	//青眼白龙的名字是固定的，不能修改的，因此被final修饰。final也可以与static连用
	private static final String name = "BlueEyeWhiteDragon";
	
	//super关键字，调用父类方法
	public void testSuper() {
		super.attack();
	}
	
	//这是方法的重写，用@Override注解标注
	@Override
	public String attack() {
		return "毁灭的爆裂疾风弹";
		
	}
}

1.7 关键字：this 、 static、final 、super

这几个关键字是类中常用的关键字。

1.7.1 this

this 指代的是类"自己"。我们在setter中常见。

public int getAttackPower() {
		return attackPower;
	}

	public void setAttackPower(int attackPower) {
		this.attackPower = attackPower;
	}

1.7.2 static

static 表示的是静态。可以修饰方法、属性、块(块就是大括号{}里包裹的代码)。

执行顺序: 静态块>main()>构造块>构造方法。

没被static 修饰的方法能调用static 方法，static方法不能直接调用没有修饰 static的方法。

被static 修饰的方法，能直接用 [类名.方法名] 调用。

1.7.3 final

final 译文是最终的意思，因此被final修饰的通常是常量，是不能被修改的。

//青眼白龙的名字是固定的，不能修改的，因此被final修饰。final也可以与static连用
		private static final String name = "BlueEyeWhiteDragon";

1.7.4 super

super代表的是子类调用父类的方法。

通过代码简单体现这几个关键字：

package BasicDemo07_ClassAndObject;
/**
 * @author Sharry
 * This class is used to make an example for learning
 * */
public class Monster {

	//攻击力
	private int attackPower;
	//防守力
	private int defendPower;
	//星数
	private int starLevel;
    
    //效果
	private String funtion;
    
    //动作
    public String attack() {
    	return "Attacking!";
    }

    //构造方法
	public Monster(int attackPower, int defendPower, int starLevel, String funtion) {
		super();
		this.attackPower = attackPower;
		this.defendPower = defendPower;
		this.starLevel = starLevel;
		this.funtion = funtion;
	}

	public Monster() {
		//无参构造，此处的super调用的是父类Object 的方法。万物皆对象！
		super();
	}

	public int getAttackPower() {
		return attackPower;
	}

	public void setAttackPower(int attackPower) {
		this.attackPower = attackPower;
	}

	public int getDefendPower() {
		return defendPower;
	}

	public void setDefendPower(int defendPower) {
		this.defendPower = defendPower;
	}

	public int getStarLevel() {
		return starLevel;
	}

	public void setStarLevel(int starLevel) {
		this.starLevel = starLevel;
	}

	public String getFuntion() {
		return funtion;
	}

	public void setFuntion(String funtion) {
		this.funtion = funtion;
	}
}

public class BlueEyesWhiteDragon extends Monster {
	//青眼白龙的名字是固定的，不能修改的，因此被final修饰。final也可以与static连用
		private static final String name = "BlueEyeWhiteDragon";
		
		//super关键字，调用父类方法
		public void testSuper() {
			super.attack();
		}
		
		//这是方法的重写，用@Override注解标注
		@Override
		public String attack() {
			return "毁灭的爆裂疾风弹";
			
		}
}

public class LearningDemo  {

	public static void main(String[] args)throws NullPointerException {
		// TODO Auto-generated method stub
		Monster m = new Monster();
		System.out.println(m.attack());
		
		//多态的体现。
		//向上造型:父类引用子类。怪兽可以是青眼白龙。
		Monster b1 = new BlueEyesWhiteDragon();
		System.out.println(b1.attack());
		
		//向下转型,青眼白龙也是怪兽，但要注意类型强转以及instanceOf
		//BlueEyesWhiteDragon b2 = (BlueEyesWhiteDragon) new Monster(); 此句会报异常
		if(b1 instanceof Monster){
			b1 = new Monster();
			System.out.println(b1.attack());
		}else {
			System.out.println("你的青眼白龙继承错啦");
		}
	}

}

示例代码中的造型是多态的体现。其中向下转型通常是先向上造型再向下转型。

1.8 单例模式

什么是单例模式？

单例模式又叫做 Singleton模式，指的是一个类，在一个JVM里，只有一个实例存在。很好地节约了资源。适用于只需要加载一次的实例。

单例模式有： 饿汉式 和 懒汉式。两者的异同在下面的例子介绍可体现:

1.8.1 饿汉式单例模式

饿汉模式代码体现:

package BasicDemo07_ClassAndObject;
/**
 * This class is used to test 
 * @author Sharry
 * 用于学习
 * */
public class HungryInstance {
    //饿汉式
	
	//类的属性、方法
	private int age;
	
	public void hungry() {
		System.out.println("I'm a hungry instance");
	}
	
	//构造方法私有化，是单例模式的一个特征，让外部类无法直接new 该类的对象
	private HungryInstance() {
		
	}
	
	//通过类属性，提供间接的创建对象方法
	//类属性:为了保证只加载一次，节约资源，使用static 修饰
	private static HungryInstance instance = new HungryInstance();
	
	//指向该类属性的方法
	public static HungryInstance getInstance() {
		return instance;
	}
}

测试上面的饿汉模式:

package BasicDemo07_ClassAndObject;
/**
 * This class is used to test 
 * @author Sharry
 * 用于学习
 * */
public class TestInstance {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        HungryInstance hungryInstance = HungryInstance.getInstance();
        //运行一次检查效果
        hungryInstance.hungry();
        
        //多个引用指向该实例，检查单例效果:
        HungryInstance h1 = HungryInstance.getInstance();
        HungryInstance h2 = HungryInstance.getInstance();
        
        //输出的hashCode一致
        System.out.println(h1);
        System.out.println(hungryInstance);
        //true
        System.out.println(h1==h2);
	}

}

1.8.2 懒汉式单例模式

饿汉模式体现了只需要加载一次的类的硬件资源的控制，那么懒汉模式是对时间资源的控制，即用到的时候再给你创建实例，“更懒一些”:

//懒汉式
	
	//类的属性、方法
		private int age;
		
		public void lazy() {
			System.out.println("I'm a lazy instance");
		}
		
		//构造方法私有化
		private LazyInstance() {
			
		}
		
		//通过类属性，提供间接的创建对象方法
		//先让它=null，需要用到的时候再创建实例
		private static LazyInstance instance = null;

		
		//指向该类属性的方法
		public static LazyInstance getInstance() {
			if(instance==null){
				instance = new LazyInstance();
			}
			return instance;
		}

1.7.3 单例模式三大特性:

  1. 构造方法私有化
  2. 静态属性指向实例
  3. public static的 getInstance方法，返回第二步的静态属性

二、枚举

枚举是一种特殊的类，enum，里面放常量（常量通常大写），常与switch搭配，定死case 的取值范围。

有空多去了解一下枚举吧！

举报

相关推荐

JAVA 面向对象05-继承

javaidea

java笔记05 面向对象oop

java开发语言后端

Java基础-面向对象-面向对象思维

Java基础/面向对象Java工程师知识树

080 01 Android 零基础入门 02 Java面向对象 01 Java面向对象基础 01 初识面向对象 05 单一职责原则

单一职责原则面向对象封装编程语言

java面向对象基础

日记本饥人谷技术博客

Java基础——面向对象

面向对象对象的内存图成员变量与局部变量匿名对象成员变量jQuery前端开发

Java面向对象基础

java子类构造方法父类系统/运维

JAVA基础--面向对象

java

Java基础：Java面向对象

子类父类多态面向对象Java后端开发

Java基础-面向对象-面向对象的特征

Java基础/面向对象Java工程师知识树
0 条评论